mm-sol 0.7.4__py3-none-any.whl → 0.8.0__py3-none-any.whl

mm_sol/__init__.py

@@ -0,0 +1 @@
+"""Library for interacting with Solana blockchain."""

mm_sol/account.py

@@ -1,3 +1,5 @@
+"""Solana account management: key generation, derivation, and validation."""
+
 import contextlib
 from dataclasses import dataclass
 
@@ -8,10 +10,15 @@ from solders.keypair import Keypair
 from solders.pubkey import Pubkey
 
 PHANTOM_DERIVATION_PATH = "m/44'/501'/{i}'/0'"
+"""Default Phantom wallet derivation path template."""
+
 WORD_STRENGTH = {12: 128, 15: 160, 18: 192, 21: 224, 24: 256}
+"""Mapping of mnemonic word count to entropy bits."""
 
 
 class NewAccount(BaseModel):
+    """Newly generated Solana account with public and private keys."""
+
     public_key: str
     private_key_base58: str
     private_key_arr: list[int]
@@ -19,6 +26,8 @@ class NewAccount(BaseModel):
 
 @dataclass
 class DerivedAccount:
+    """Account derived from a mnemonic at a specific derivation path."""
+
     index: int
     path: str
     address: str
@@ -26,6 +35,7 @@ class DerivedAccount:
 
 
 def generate_mnemonic(num_words: int = 24) -> str:
+    """Generate a BIP39 mnemonic phrase with the specified number of words."""
     if num_words not in WORD_STRENGTH:
         raise ValueError(f"num_words must be one of {list(WORD_STRENGTH.keys())}")
     mnemonic = Mnemonic("english")
@@ -33,6 +43,7 @@ def generate_mnemonic(num_words: int = 24) -> str:
 
 
 def derive_accounts(mnemonic: str, passphrase: str, derivation_path: str, limit: int) -> list[DerivedAccount]:
+    """Derive multiple accounts from a mnemonic using the given derivation path template."""
     if "{i}" not in derivation_path:
         raise ValueError("derivation_path must contain {i}, for example: m/44'/501'/{i}'/0'")
 
@@ -54,6 +65,7 @@ def derive_accounts(mnemonic: str, passphrase: str, derivation_path: str, limit:
 
 
 def generate_account() -> NewAccount:
+    """Generate a new random Solana keypair and return it as a NewAccount."""
     keypair = Keypair()
     public_key = str(keypair.pubkey())
     private_key_base58 = base58.b58encode(bytes(keypair.to_bytes())).decode("utf-8")
@@ -62,6 +74,7 @@ def generate_account() -> NewAccount:
 
 
 def get_keypair(private_key: str | list[int]) -> Keypair:
+    """Create a Keypair from a base58 string, JSON array string, or integer list."""
     if isinstance(private_key, str):
         if "[" in private_key:
             private_key_ = [int(x) for x in private_key.replace("[", "").replace("]", "").split(",")]
@@ -73,12 +86,14 @@ def get_keypair(private_key: str | list[int]) -> Keypair:
 
 
 def check_private_key(public_key: str | Pubkey, private_key: str | list[int]) -> bool:
+    """Check whether a private key corresponds to the given public key."""
     if isinstance(public_key, str):
         public_key = Pubkey.from_string(public_key)
     return get_keypair(private_key).pubkey() == public_key
 
 
 def get_public_key(private_key: str) -> str:
+    """Derive the public key address from a private key string."""
     if "[" in private_key:
         private_key_ = [int(x) for x in private_key.replace("[", "").replace("]", "").split(",")]
     else:
@@ -87,20 +102,24 @@ def get_public_key(private_key: str) -> str:
 
 
 def get_private_key_base58(private_key: str) -> str:
+    """Convert a private key to base58 encoding."""
     keypair = get_keypair(private_key)
     return base58.b58encode(bytes(keypair.to_bytes())).decode("utf-8")
 
 
 def get_private_key_arr(private_key: str) -> list[int]:
+    """Convert a private key to a list of byte integers."""
     keypair = get_keypair(private_key)
     return list(x for x in keypair.to_bytes())  # noqa: C400
 
 
 def get_private_key_arr_str(private_key: str) -> str:
+    """Convert a private key to a JSON-style array string."""
     return f"[{','.join(str(x) for x in get_private_key_arr(private_key))}]"
 
 
 def is_address(pubkey: str) -> bool:
+    """Check whether a string is a valid Solana address."""
     with contextlib.suppress(Exception):
         Pubkey.from_string(pubkey)
         return True

mm_sol/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI interface for mm-sol."""

mm_sol/cli/calcs.py

@@ -1,3 +1,5 @@
+"""Value expression calculators for SOL and token amounts with optional balance variables."""
+
 from mm_result import Result
 from mm_web3 import Nodes, Proxies
 from mm_web3.calcs import calc_expression_with_vars
@@ -7,16 +9,19 @@ from mm_sol.constants import UNIT_DECIMALS
 
 
 def calc_sol_expression(expression: str, variables: dict[str, int] | None = None) -> int:
+    """Evaluate a SOL expression string into lamports."""
     return calc_expression_with_vars(expression, variables, unit_decimals=UNIT_DECIMALS)
 
 
 def calc_token_expression(expression: str, token_decimals: int, variables: dict[str, int] | None = None) -> int:
+    """Evaluate a token expression string into smallest units."""
     return calc_expression_with_vars(expression, variables, unit_decimals={"t": token_decimals})
 
 
 async def calc_sol_value_for_address(
     *, nodes: Nodes, value_expression: str, address: str, proxies: Proxies, fee: int
 ) -> Result[int]:
+    """Calculate SOL value in lamports for an address, resolving 'balance' variable if used."""
     value_expression = value_expression.lower()
     variables: dict[str, int] | None = None
     if "balance" in value_expression:
@@ -34,6 +39,7 @@ async def calc_sol_value_for_address(
 async def calc_token_value_for_address(
     *, nodes: Nodes, value_expression: str, owner: str, token: str, token_decimals: int, proxies: Proxies
 ) -> Result[int]:
+    """Calculate token value in smallest units for an address, resolving 'balance' variable if used."""
     variables: dict[str, int] | None = None
     value_expression = value_expression.lower()
     if "balance" in value_expression:

mm_sol/cli/cli.py

@@ -1,10 +1,12 @@
+"""Main CLI entry point and command definitions for mm-sol."""
+
 import asyncio
-from enum import Enum
+from enum import StrEnum
 from pathlib import Path
 from typing import Annotated
 
-import mm_print
 import typer
+from mm_print import print_plain
 
 from mm_sol.account import PHANTOM_DERIVATION_PATH
 
@@ -13,8 +15,10 @@ 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
 
+"""Main CLI application."""
 app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
 
+"""Wallet subcommand group."""
 wallet_app = typer.Typer(
     no_args_is_help=True, help="Wallet-related commands: generate new accounts, derive addresses from private keys, and more"
 )
@@ -23,23 +27,27 @@ app.add_typer(wallet_app, name="w", hidden=True)
 
 
 def version_callback(value: bool) -> None:
+    """Print version and exit when --version is passed."""
     if value:
-        mm_print.plain(f"mm-sol: {cli_utils.get_version()}")
+        print_plain(f"mm-sol: {cli_utils.get_version()}")
         raise typer.Exit
 
 
 @app.callback()
 def main(_version: bool = typer.Option(None, "--version", callback=version_callback, is_eager=True)) -> None:
-    pass
+    """Solana CLI tool."""
+
 
+class ConfigExample(StrEnum):
+    """Available example configuration names."""
 
-class ConfigExample(str, Enum):
     balances = "balances"
     transfer = "transfer"
 
 
 @app.command(name="example", help="Displays an example configuration for a command")
 def example_command(command: Annotated[ConfigExample, typer.Argument()]) -> None:
+    """Display an example configuration for the given command."""
     example_cmd.run(command.value)
 
 
@@ -51,6 +59,7 @@ def balance_command(
     proxies_url: Annotated[str, typer.Option("--proxies-url", envvar="MM_SOL_PROXIES_URL")] = "",  # nosec
     lamport: bool = typer.Option(False, "--lamport", "-l", help="Print balances in lamports"),
 ) -> None:
+    """Fetch and print SOL and optional token balance for an account."""
     asyncio.run(balance_cmd.run(rpc_url, wallet_address, token_address, lamport, proxies_url))
 
 
@@ -58,6 +67,7 @@ def balance_command(
 def balances_command(
     config_path: Path, print_config: Annotated[bool, typer.Option("--config", "-c", help="Print config and exit")] = False
 ) -> None:
+    """Display SOL and token balances for multiple accounts from a config file."""
     asyncio.run(balances_cmd.run(config_path, print_config))
 
 
@@ -72,6 +82,7 @@ def transfer_command(
     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:
+    """Execute SOL or SPL token transfers based on a config file."""
     asyncio.run(
         transfer_cmd.run(
             TransferCmdParams(
@@ -93,6 +104,7 @@ def node_command(
     urls: Annotated[list[str], typer.Argument()],
     proxy: Annotated[str | None, typer.Option("--proxy", "-p", help="Proxy")] = None,
 ) -> None:
+    """Check RPC node availability by fetching block height."""
     asyncio.run(node_cmd.run(urls, proxy))
 
 
@@ -105,11 +117,13 @@ def wallet_mnemonic_command(  # nosec
     words: int = typer.Option(12, "--words", "-w", help="Number of mnemonic words"),
     limit: int = typer.Option(5, "--limit", "-l"),
 ) -> None:
+    """Generate or derive accounts from a mnemonic phrase."""
     mnemonic_cmd.run(mnemonic, passphrase, words, derivation_path, limit)
 
 
 @wallet_app.command(name="keypair", help="Print public, private_base58, private_arr by a private key")
 def keypair_command(private_key: str) -> None:
+    """Print keypair details from a private key."""
     keypair_cmd.run(private_key)
 
 

mm_sol/cli/cli_utils.py

@@ -1,9 +1,13 @@
+"""Shared CLI utilities: config printing, RPC URL resolution, and helpers."""
+
 import importlib.metadata
 import time
 from pathlib import Path
+from typing import NoReturn
 
-import mm_print
+import typer
 from loguru import logger
+from mm_print import print_json
 from mm_web3 import Nodes, Proxies, Web3CliConfig, random_node, random_proxy
 from pydantic import BaseModel
 from solders.signature import Signature
@@ -12,23 +16,28 @@ from mm_sol.utils import get_client
 
 
 def get_version() -> str:
+    """Return the installed mm-sol package version."""
     return importlib.metadata.version("mm-sol")
 
 
 class BaseConfigParams(BaseModel):
+    """Base parameters shared by CLI commands that read a config file."""
+
     config_path: Path
     print_config_and_exit: bool
 
 
 def print_config(config: Web3CliConfig, exclude: set[str] | None = None, count: set[str] | None = None) -> None:
+    """Print a config as JSON, optionally replacing list fields with their counts."""
     data = config.model_dump(exclude=exclude)
     if count:
         for k in count:
             data[k] = len(data[k])
-    mm_print.json(data)
+    print_json(data)
 
 
 def public_rpc_url(url: str | None) -> str:
+    """Resolve a shorthand network name (mainnet/testnet/devnet) to its full RPC URL."""
     if not url:
         return "https://api.mainnet-beta.solana.com"
 
@@ -44,6 +53,7 @@ def public_rpc_url(url: str | None) -> str:
 
 
 def wait_confirmation(nodes: Nodes, proxies: Proxies, signature: Signature, log_prefix: str) -> bool:
+    """Poll for transaction confirmation, returning True if confirmed within 30 seconds."""
     count = 0
     while True:
         try:
@@ -60,3 +70,9 @@ def wait_confirmation(nodes: Nodes, proxies: Proxies, signature: Signature, log_
         if count > 30:
             logger.error(f"{log_prefix}: can't get confirmation, timeout")
             return False
+
+
+def fatal(message: str) -> NoReturn:
+    """Print an error message and exit with code 1."""
+    typer.echo(message)
+    raise typer.Exit(1)

mm_sol/cli/cmd/__init__.py

@@ -0,0 +1 @@
+"""CLI command implementations."""

mm_sol/cli/cmd/balance_cmd.py

@@ -1,6 +1,8 @@
+"""Single account balance query command."""
+
 from decimal import Decimal
 
-import mm_print
+from mm_print import print_json
 from mm_web3 import fetch_proxies
 from pydantic import BaseModel, Field
 
@@ -10,6 +12,8 @@ from mm_sol.cli import cli_utils
 
 
 class HumanReadableBalanceResult(BaseModel):
+    """Balance result with SOL and token values in human-readable decimals."""
+
     sol_balance: Decimal | None
     token_balance: Decimal | None
     token_decimals: int | None
@@ -17,12 +21,15 @@ class HumanReadableBalanceResult(BaseModel):
 
 
 class BalanceResult(BaseModel):
+    """Balance result with SOL and token values in smallest units."""
+
     sol_balance: int | None = None
     token_balance: int | None = None
     token_decimals: int | None = None
     errors: list[str] = Field(default_factory=list)
 
     def to_human_readable(self) -> HumanReadableBalanceResult:
+        """Convert balances from smallest units to human-readable decimals."""
         sol_balance = Decimal(self.sol_balance) / 10**9 if self.sol_balance is not None else None
         token_balance = None
         if self.token_balance is not None and self.token_decimals is not None:
@@ -39,6 +46,7 @@ async def run(
     lamport: bool,
     proxies_url: str | None,
 ) -> None:
+    """Fetch and print SOL and optional token balance for a single account."""
     result = BalanceResult()
 
     rpc_url = cli_utils.public_rpc_url(rpc_url)
@@ -68,6 +76,6 @@ async def run(
             result.errors.append("token_decimals: " + decimals_res.unwrap_err())
 
     if lamport:
-        mm_print.json(result)
+        print_json(result)
     else:
-        mm_print.json(result.to_human_readable())
+        print_json(result.to_human_readable())

mm_sol/cli/cmd/balances_cmd.py

@@ -1,18 +1,23 @@
+"""Multi-account balances query command."""
+
 import random
 from decimal import Decimal
 from pathlib import Path
 from typing import Annotated, Any
 
-import mm_print
+from mm_print import print_json
 from mm_web3 import ConfigValidators, Web3CliConfig
 from pydantic import BeforeValidator, Field
 
 import mm_sol.retry
 from mm_sol import converters, retry
+from mm_sol.cli.cli_utils import fatal
 from mm_sol.cli.validators import Validators
 
 
 class Config(Web3CliConfig):
+    """Configuration for the balances command."""
+
     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())]
@@ -20,10 +25,12 @@ class Config(Web3CliConfig):
 
     @property
     def random_node(self) -> str:
+        """Return a randomly selected RPC node URL."""
         return random.choice(self.nodes)
 
 
 async def run(config_path: Path, print_config: bool) -> None:
+    """Fetch and print SOL and token balances for all configured accounts."""
     config = Config.read_toml_config_or_exit(config_path)
     if print_config:
         config.print_and_exit()
@@ -35,19 +42,20 @@ async def run(config_path: Path, print_config: bool) -> None:
         for token_address in config.tokens:
             res = await mm_sol.retry.get_token_decimals(3, config.nodes, config.proxies, token=token_address)
             if res.is_err():
-                mm_print.exit_with_error(f"Failed to get decimals for token {token_address}: {res.unwrap_err()}")
+                fatal(f"Failed to get decimals for token {token_address}: {res.unwrap_err()}")
 
             token_decimals = res.unwrap()
             result[token_address] = await _get_token_balances(token_address, token_decimals, config.accounts, config)
             result[token_address + "_decimals"] = token_decimals
             result[token_address + "_sum"] = sum([v for v in result[token_address].values() if v is not None])
 
-    mm_print.json(result)
+    print_json(result)
 
 
 async def _get_token_balances(
     token_address: str, token_decimals: int, accounts: list[str], config: Config
 ) -> dict[str, Decimal | None]:
+    """Fetch token balances for all accounts, returning a dict of address to balance."""
     result: dict[str, Decimal | None] = {}
     for account in accounts:
         result[account] = (
@@ -60,12 +68,11 @@ async def _get_token_balances(
 
 
 async def _get_sol_balances(accounts: list[str], config: Config) -> dict[str, Decimal | None]:
+    """Fetch SOL balances for all accounts, returning a dict of address to balance."""
     result = {}
     for account in accounts:
         result[account] = (
-            (await retry.get_sol_balance(3, config.nodes, config.proxies, address=account))
-            .map(lambda v: converters.lamports_to_sol(v))
-            .value
+            (await retry.get_sol_balance(3, config.nodes, config.proxies, address=account)).map(converters.lamports_to_sol).value
         )
 
     return result

mm_sol/cli/cmd/example_cmd.py

@@ -1,8 +1,11 @@
+"""Example config display command."""
+
 from pathlib import Path
 
-import mm_print
+from mm_print import print_toml
 
 
 def run(module: str) -> None:
+    """Print the example TOML configuration for the given command module."""
     example_file = Path(Path(__file__).parent.absolute(), "../examples", f"{module}.toml")
-    mm_print.toml(example_file.read_text())
+    print_toml(example_file.read_text())

mm_sol/cli/cmd/node_cmd.py

@@ -1,11 +1,14 @@
-import mm_print
+"""RPC node health check command."""
+
+from mm_print import print_json
 
 from mm_sol import rpc
 from mm_sol.cli import cli_utils
 
 
 async def run(urls: list[str], proxy: str | None) -> None:
+    """Check each RPC URL by fetching block height and print results."""
     result = {}
     for url in [cli_utils.public_rpc_url(u) for u in urls]:
         result[url] = (await rpc.get_block_height(url, proxy=proxy, timeout=10)).value_or_error()
-    mm_print.json(data=result)
+    print_json(data=result)

mm_sol/cli/cmd/transfer_cmd.py

@@ -1,11 +1,12 @@
+"""SOL and SPL token transfer command with multi-route support."""
+
 import asyncio
 import sys
 from pathlib import Path
 from typing import Annotated
 
-import mm_print
 from loguru import logger
-from mm_std import utc_now
+from mm_std import utc
 from mm_web3 import Web3CliConfig
 from mm_web3.account import PrivateKeyMap
 from mm_web3.calcs import calc_decimal_expression
@@ -20,12 +21,14 @@ from solders.signature import Signature
 import mm_sol.retry
 from mm_sol import retry
 from mm_sol.cli import calcs, cli_utils
-from mm_sol.cli.cli_utils import BaseConfigParams
+from mm_sol.cli.cli_utils import BaseConfigParams, fatal
 from mm_sol.cli.validators import Validators
 from mm_sol.converters import lamports_to_sol, to_token
 
 
 class Config(Web3CliConfig):
+    """Transfer command configuration with routes, keys, and value expressions."""
+
     nodes: Annotated[list[str], BeforeValidator(Validators.nodes())]
     transfers: Annotated[list[Transfer], BeforeValidator(Validators.sol_transfers())]
     private_keys: Annotated[PrivateKeyMap, BeforeValidator(Validators.sol_private_keys())]
@@ -41,10 +44,12 @@ class Config(Web3CliConfig):
 
     @property
     def from_addresses(self) -> list[str]:
+        """Return the list of sender addresses from all transfer routes."""
         return [r.from_address for r in self.transfers]
 
     @model_validator(mode="after")  # type: ignore[misc]
-    async def final_validator(self) -> "Config":
+    async def final_validator(self) -> Config:
+        """Validate private keys, transfer values, and fetch token decimals if needed."""
         if not self.private_keys.contains_all_addresses(self.from_addresses):
             raise ValueError("private keys are not set for all addresses")
 
@@ -69,13 +74,15 @@ class Config(Web3CliConfig):
         if self.token:
             res = await mm_sol.retry.get_token_decimals(3, self.nodes, self.proxies, token=self.token)
             if res.is_err():
-                mm_print.exit_with_error(f"can't get decimals for token={self.token}, error={res.unwrap_err()}")
+                fatal(f"can't get decimals for token={self.token}, error={res.unwrap_err()}")
             self.token_decimals = res.unwrap()
 
         return self
 
 
 class TransferCmdParams(BaseConfigParams):
+    """CLI parameters for the transfer command."""
+
     print_balances: bool
     print_transfers: bool
     debug: bool
@@ -85,6 +92,7 @@ class TransferCmdParams(BaseConfigParams):
 
 
 async def run(cmd_params: TransferCmdParams) -> None:
+    """Execute the transfer command: print config/balances/transfers or run transfers."""
     config = await Config.read_toml_config_or_exit_async(cmd_params.config_path)
 
     if cmd_params.print_config_and_exit:
@@ -103,8 +111,9 @@ async def run(cmd_params: TransferCmdParams) -> None:
 
 
 async def _run_transfers(config: Config, cmd_params: TransferCmdParams) -> None:
+    """Execute all configured transfer routes sequentially with optional delays."""
     init_loguru(cmd_params.debug, config.log_debug, config.log_info)
-    logger.info(f"transfer {cmd_params.config_path}: started at {utc_now()} UTC")
+    logger.info(f"transfer {cmd_params.config_path}: started at {utc()} UTC")
     logger.debug(f"config={config.model_dump(exclude={'private_keys'}) | {'version': cli_utils.get_version()}}")
     for i, route in enumerate(config.transfers):
         await _transfer(route, config, cmd_params)
@@ -113,10 +122,11 @@ async def _run_transfers(config: Config, cmd_params: TransferCmdParams) -> None:
             logger.info(f"delay {delay_value} seconds")
             if not cmd_params.emulate:
                 await asyncio.sleep(float(delay_value))
-    logger.info(f"transfer {cmd_params.config_path}: finished at {utc_now()} UTC")
+    logger.info(f"transfer {cmd_params.config_path}: finished at {utc()} UTC")
 
 
 async def _calc_value(transfer: Transfer, config: Config, transfer_sol_fee: int) -> int | None:
+    """Calculate the transfer value in smallest units, resolving balance-based expressions."""
     if config.token:
         value_res = await calcs.calc_token_value_for_address(
             nodes=config.nodes,
@@ -142,7 +152,7 @@ async def _calc_value(transfer: Transfer, config: Config, transfer_sol_fee: int)
 
 
 def _check_value_min_limit(transfer: Transfer, value: int, config: Config) -> bool:
-    """Returns False if the transfer should be skipped."""
+    """Return False if the transfer value is below the configured minimum limit."""
     if config.value_min_limit:
         if config.token:
             value_min_limit = calcs.calc_token_expression(config.value_min_limit, config.token_decimals)
@@ -154,12 +164,14 @@ def _check_value_min_limit(transfer: Transfer, value: int, config: Config) -> bo
 
 
 def _value_with_suffix(value: int, config: Config) -> str:
+    """Format a value with its unit suffix (sol or t)."""
     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"
 
 
 async def _send_tx(transfer: Transfer, value: int, config: Config) -> Signature | None:
+    """Submit a SOL or token transfer transaction with retries."""
     logger.debug(f"{transfer.log_prefix}: value={_value_with_suffix(value, config)}")
     if config.token:
         res = await retry.transfer_token(
@@ -191,6 +203,7 @@ async def _send_tx(transfer: Transfer, value: int, config: Config) -> Signature
 
 
 async def _transfer(transfer: Transfer, config: Config, cmd_params: TransferCmdParams) -> None:
+    """Execute a single transfer route: calculate value, check limits, send, and confirm."""
     transfer_sol_fee = 5000
 
     value = await _calc_value(transfer, config, transfer_sol_fee)
@@ -218,6 +231,7 @@ async def _transfer(transfer: Transfer, config: Config, cmd_params: TransferCmdP
 
 
 def _print_transfers(config: Config) -> None:
+    """Print a table of all configured transfer routes."""
     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)
@@ -226,6 +240,7 @@ def _print_transfers(config: Config) -> None:
 
 
 async def _print_balances(config: Config) -> None:
+    """Print a live-updating table of SOL and token balances for all transfer routes."""
     if config.token:
         headers = ["n", "from_address", "sol", "t", "to_address", "sol", "t"]
     else:
@@ -259,11 +274,13 @@ async def _print_balances(config: Config) -> None:
 
 
 async def _get_sol_balance_str(address: str, config: Config) -> str:
+    """Fetch SOL balance and return it as a formatted string."""
     res = await retry.get_sol_balance(5, config.nodes, config.proxies, address=address)
     return res.map(lambda ok: str(lamports_to_sol(ok, config.round_ndigits))).value_or_error()
 
 
 async def _get_token_balance_str(address: str, config: Config) -> str:
+    """Fetch token balance and return it as a formatted string."""
     if not config.token:
         raise ValueError("token is not set")
     res = await mm_sol.retry.get_token_balance(5, config.nodes, config.proxies, owner=address, token=config.token)

mm_sol/cli/cmd/wallet/__init__.py

@@ -0,0 +1 @@
+"""Wallet-related CLI commands."""

mm_sol/cli/cmd/wallet/keypair_cmd.py

@@ -1,6 +1,8 @@
+"""Keypair details display command."""
+
 from pathlib import Path
 
-import mm_print
+from mm_print import print_json
 
 from mm_sol.account import (
     get_private_key_arr_str,
@@ -10,10 +12,11 @@ from mm_sol.account import (
 
 
 def run(private_key: str) -> None:
+    """Print public key, base58 private key, and array private key from a private key input."""
     if (file := Path(private_key)).is_file():
         private_key = file.read_text()
 
     public = get_public_key(private_key)
     private_base58 = get_private_key_base58(private_key)
     private_arr = get_private_key_arr_str(private_key)
-    mm_print.json({"public": public, "private_base58": private_base58, "private_arr": private_arr})
+    print_json({"public": public, "private_base58": private_base58, "private_arr": private_arr})

mm_sol/cli/cmd/wallet/mnemonic_cmd.py

@@ -1,12 +1,15 @@
+"""Mnemonic generation and account derivation command."""
+
 from dataclasses import asdict
 from typing import Any
 
-import mm_print
+from mm_print import print_json
 
 from mm_sol.account import derive_accounts, generate_mnemonic
 
 
 def run(mnemonic: str, passphrase: str, words: int, derivation_path: str, limit: int) -> None:  # nosec
+    """Generate or use a mnemonic to derive accounts and print results."""
     result: dict[str, Any] = {}
     if not mnemonic:
         mnemonic = generate_mnemonic(words)
@@ -16,4 +19,4 @@ def run(mnemonic: str, passphrase: str, words: int, derivation_path: str, limit:
     accounts = derive_accounts(mnemonic=mnemonic, passphrase=passphrase, derivation_path=derivation_path, limit=limit)
 
     result["accounts"] = [asdict(acc) for acc in accounts]
-    mm_print.json(result)
+    print_json(result)

mm_sol/cli/validators.py

@@ -1,3 +1,5 @@
+"""Solana-specific config validators for CLI commands."""
+
 from collections.abc import Callable
 
 from mm_web3 import ConfigValidators
@@ -9,30 +11,39 @@ from mm_sol.constants import UNIT_DECIMALS
 
 
 class Validators(ConfigValidators):
+    """Pydantic validators for Solana addresses, private keys, and value expressions."""
+
     @staticmethod
     def sol_address() -> Callable[[str], str]:
+        """Return a validator for a single Solana address."""
         return ConfigValidators.address(is_address)
 
     @staticmethod
     def sol_addresses(unique: bool) -> Callable[[str], list[str]]:
+        """Return a validator for a list of Solana addresses."""
         return ConfigValidators.addresses(unique, is_address=is_address)
 
     @staticmethod
     def sol_transfers() -> Callable[[str], list[Transfer]]:
+        """Return a validator for transfer routes with Solana addresses."""
         return ConfigValidators.transfers(is_address)
 
     @staticmethod
     def sol_private_keys() -> Callable[[str], PrivateKeyMap]:
+        """Return a validator for private key mappings."""
         return ConfigValidators.private_keys(get_public_key)
 
     @staticmethod
     def valid_sol_expression(var_name: str | None = None) -> Callable[[str], str]:
+        """Return a validator for SOL value expressions."""
         return ConfigValidators.expression_with_vars(var_name, UNIT_DECIMALS)
 
     @staticmethod
     def valid_token_expression(var_name: str | None = None) -> Callable[[str], str]:
+        """Return a validator for token value expressions with 6 decimal places."""
         return ConfigValidators.expression_with_vars(var_name, {"t": 6})
 
     @staticmethod
     def valid_sol_or_token_expression(var_name: str | None = None) -> Callable[[str], str]:
+        """Return a validator accepting both SOL and token value expressions."""
         return ConfigValidators.expression_with_vars(var_name, UNIT_DECIMALS | {"t": 6})

mm_sol/constants.py

@@ -1 +1,4 @@
+"""Solana-related constants."""
+
 UNIT_DECIMALS = {"sol": 9}
+"""Mapping of unit name to decimal places."""

mm_sol/converters.py

@@ -1,23 +1,29 @@
+"""Conversion utilities between SOL, lamports, and token smallest units."""
+
 from decimal import Decimal
 
 
 def lamports_to_sol(lamports: int, ndigits: int = 4) -> Decimal:
+    """Convert lamports to SOL with the specified decimal precision."""
     if lamports == 0:
         return Decimal(0)
     return Decimal(str(round(lamports / 10**9, ndigits=ndigits)))
 
 
 def to_token(smallest_unit_value: int, decimals: int, ndigits: int = 4) -> Decimal:
+    """Convert a token's smallest unit value to a human-readable Decimal."""
     if smallest_unit_value == 0:
         return Decimal(0)
     return Decimal(str(round(smallest_unit_value / 10**decimals, ndigits=ndigits)))
 
 
 def sol_to_lamports(sol: Decimal) -> int:
+    """Convert SOL amount to lamports."""
     return int(sol * 10**9)
 
 
 def to_lamports(value: str | int | Decimal, decimals: int | None = None) -> int:
+    """Parse a value into lamports. Supports raw int, Decimal, or string with 'sol'/'t' suffix."""
     if isinstance(value, int):
         return value
     if isinstance(value, Decimal):

mm_sol/retry.py

@@ -1,3 +1,5 @@
+"""Retry wrappers for Solana RPC calls with node and proxy rotation."""
+
 from mm_result import Result
 from mm_web3 import Nodes, Proxies, retry_with_node_and_proxy
 from solders.solders import Pubkey, Signature
@@ -6,6 +8,7 @@ from mm_sol import rpc, spl_token, transfer
 
 
 async def get_sol_balance(retries: int, nodes: Nodes, proxies: Proxies, *, address: str, timeout: float = 5) -> Result[int]:
+    """Fetch SOL balance in lamports with retries across nodes and proxies."""
     return await retry_with_node_and_proxy(
         retries,
         nodes,
@@ -24,6 +27,7 @@ async def get_token_balance(
     token_account: str | None = None,
     timeout: float = 5,
 ) -> Result[int]:
+    """Fetch SPL token balance with retries across nodes and proxies."""
     return await retry_with_node_and_proxy(
         retries,
         nodes,
@@ -53,6 +57,7 @@ async def transfer_token(
     timeout: float = 10,
     create_token_account_if_not_exists: bool = True,
 ) -> Result[Signature]:
+    """Transfer SPL tokens with retries across nodes and proxies."""
     return await retry_with_node_and_proxy(
         retries,
         nodes,
@@ -83,6 +88,7 @@ async def transfer_sol(
     lamports: int,
     timeout: float = 10,
 ) -> Result[Signature]:
+    """Transfer SOL with retries across nodes and proxies."""
     return await retry_with_node_and_proxy(
         retries,
         nodes,
@@ -100,6 +106,7 @@ async def transfer_sol(
 
 
 async def get_token_decimals(retries: int, nodes: Nodes, proxies: Proxies, *, token: str, timeout: float = 5) -> Result[int]:
+    """Fetch token decimals with retries across nodes and proxies."""
     return await retry_with_node_and_proxy(
         retries,
         nodes,

mm_sol/rpc.py

@@ -1,3 +1,5 @@
+"""Async Solana JSON-RPC client with HTTP and WebSocket support."""
+
 import json
 from collections.abc import Sequence
 from typing import Any
@@ -15,6 +17,7 @@ async def rpc_call(
     proxy: str | None,
     id_: int = 1,
 ) -> Result[Any]:
+    """Send a JSON-RPC request to a Solana node via HTTP or WebSocket."""
     data = {"jsonrpc": "2.0", "method": method, "params": params, "id": id_}
     if node.startswith("http"):
         return await _http_call(node, data, timeout, proxy)
@@ -22,11 +25,12 @@ async def rpc_call(
 
 
 async def _http_call(node: str, data: dict[str, object], timeout: float, proxy: str | None) -> Result[Any]:
+    """Execute an RPC call over HTTP."""
     res = await http_request(node, method="POST", proxy=proxy, timeout=timeout, json=data)
     if res.is_err():
         return res.to_result_err()
     try:
-        parsed_body = res.parse_json()
+        parsed_body = res.json_body().unwrap("invalid_json")
         err = parsed_body.get("error", {}).get("message", "")
         if err:
             return res.to_result_err(f"service_error: {err}")
@@ -38,6 +42,7 @@ async def _http_call(node: str, data: dict[str, object], timeout: float, proxy:
 
 
 async def _ws_call(node: str, data: dict[str, object], timeout: float) -> Result[Any]:
+    """Execute an RPC call over WebSocket."""
     response = None
     try:
         async with websockets.connect(node, open_timeout=timeout) as ws:
@@ -57,11 +62,12 @@ async def _ws_call(node: str, data: dict[str, object], timeout: float) -> Result
 
 
 async def get_block_height(node: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
+    """Return the current block height."""
     return await rpc_call(node=node, method="getBlockHeight", params=[], timeout=timeout, proxy=proxy)
 
 
 async def get_balance(node: str, address: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
-    """Returns balance in lamports"""
+    """Return balance in lamports."""
     return (await rpc_call(node=node, method="getBalance", params=[address], timeout=timeout, proxy=proxy)).map(
         lambda r: r["value"]
     )

mm_sol/rpc_sync.py

@@ -1,3 +1,5 @@
+"""Synchronous Solana JSON-RPC client and response models."""
+
 from typing import Any
 
 import pydash
@@ -6,10 +8,15 @@ from mm_result import Result
 from pydantic import BaseModel, ConfigDict, Field
 
 DEFAULT_MAINNET_RPC = "https://api.mainnet-beta.solana.com"
+"""Default Solana mainnet RPC endpoint."""
+
 DEFAULT_TESTNET_RPC = "https://api.testnet.solana.com"
+"""Default Solana testnet RPC endpoint."""
 
 
 class EpochInfo(BaseModel):
+    """Solana epoch information from getEpochInfo RPC call."""
+
     model_config = ConfigDict(populate_by_name=True)
 
     epoch: int
@@ -21,10 +28,13 @@ class EpochInfo(BaseModel):
 
     @property
     def progress(self) -> float:
+        """Return epoch progress as a percentage."""
         return round(self.slot_index / self.slots_in_epoch * 100, 2)
 
 
 class ClusterNode(BaseModel):
+    """A node in the Solana cluster from getClusterNodes."""
+
     pubkey: str
     version: str | None
     gossip: str | None
@@ -32,7 +42,11 @@ class ClusterNode(BaseModel):
 
 
 class VoteAccount(BaseModel):
+    """Validator vote account with stake and credit info."""
+
     class EpochCredits(BaseModel):
+        """Credits earned by a validator in a single epoch."""
+
         epoch: int
         credits: int
         previous_credits: int
@@ -49,7 +63,11 @@ class VoteAccount(BaseModel):
 
 
 class BlockProduction(BaseModel):
+    """Block production statistics for a slot range."""
+
     class Leader(BaseModel):
+        """Per-leader block production stats."""
+
         address: str
         produced: int
         skipped: int
@@ -61,14 +79,18 @@ class BlockProduction(BaseModel):
 
     @property
     def total_produced(self) -> int:
+        """Return total blocks produced across all leaders."""
         return sum(leader.produced for leader in self.leaders)
 
     @property
     def total_skipped(self) -> int:
+        """Return total blocks skipped across all leaders."""
         return sum(leader.skipped for leader in self.leaders)
 
 
 class StakeActivation(BaseModel):
+    """Stake activation status for a stake account."""
+
     state: str
     active: int
     inactive: int
@@ -83,6 +105,7 @@ def rpc_call(
     timeout: float = 5,
     proxy: str | None = None,
 ) -> Result[Any]:
+    """Send a synchronous JSON-RPC request to a Solana node."""
     data = {"jsonrpc": "2.0", "method": method, "params": params, "id": id_}
     if node.startswith("http"):
         return _http_call(node, data, timeout, proxy)
@@ -90,12 +113,13 @@ def rpc_call(
 
 
 def _http_call(node: str, data: dict[str, object], timeout: float, proxy: str | None) -> Result[Any]:
+    """Execute a synchronous RPC call over HTTP."""
     res = http_request_sync(node, method="POST", proxy=proxy, timeout=timeout, json=data)
     try:
         if res.is_err():
             return res.to_result_err()
 
-        json_body = res.parse_json()
+        json_body = res.json_body().unwrap("invalid_json")
         err = pydash.get(json_body, "error.message")
         if err:
             return res.to_result_err(f"service_error: {err}")
@@ -108,35 +132,40 @@ def _http_call(node: str, data: dict[str, object], timeout: float, proxy: str |
 
 
 def get_balance(node: str, address: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
-    """Returns balance in lamports"""
+    """Return balance in lamports."""
     return rpc_call(node=node, method="getBalance", params=[address], timeout=timeout, proxy=proxy).map(lambda r: r["value"])
 
 
 def get_block_height(node: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
-    """Returns balance in lamports"""
+    """Return the current block height."""
     return rpc_call(node=node, method="getBlockHeight", params=[], timeout=timeout, proxy=proxy)
 
 
 def get_slot(node: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
+    """Return the current slot number."""
     return rpc_call(node=node, method="getSlot", params=[], timeout=timeout, proxy=proxy)
 
 
 def get_epoch_info(node: str, epoch: int | None = None, timeout: float = 5, proxy: str | None = None) -> Result[EpochInfo]:
+    """Return epoch information, optionally for a specific epoch."""
     params = [epoch] if epoch else []
     return rpc_call(node=node, method="getEpochInfo", params=params, timeout=timeout, proxy=proxy).map(lambda r: EpochInfo(**r))
 
 
 def get_health(node: str, timeout: float = 5, proxy: str | None = None) -> Result[bool]:
+    """Check whether the node is healthy."""
     return rpc_call(node=node, method="getHealth", params=[], timeout=timeout, proxy=proxy).map(lambda r: r == "ok")
 
 
 def get_cluster_nodes(node: str, timeout: float = 5, proxy: str | None = None) -> Result[list[ClusterNode]]:
+    """Return the list of cluster nodes."""
     return rpc_call(node=node, method="getClusterNodes", timeout=timeout, proxy=proxy, params=[]).map(
         lambda r: [ClusterNode(**n) for n in r],
     )
 
 
 def get_vote_accounts(node: str, timeout: float = 5, proxy: str | None = None) -> Result[list[VoteAccount]]:
+    """Return current and delinquent vote accounts."""
     res = rpc_call(node=node, method="getVoteAccounts", timeout=timeout, proxy=proxy, params=[])
     if res.is_err():
         return res
@@ -186,6 +215,7 @@ def get_leader_scheduler(
     timeout: float = 5,
     proxy: str | None = None,
 ) -> Result[dict[str, list[int]]]:
+    """Return the leader schedule, optionally for a specific slot."""
     return rpc_call(
         node=node,
         method="getLeaderSchedule",
@@ -196,6 +226,7 @@ def get_leader_scheduler(
 
 
 def get_stake_activation(node: str, address: str, timeout: float = 60, proxy: str | None = None) -> Result[StakeActivation]:
+    """Return stake activation status for a stake account address."""
     return rpc_call(node=node, method="getStakeActivation", timeout=timeout, proxy=proxy, params=[address]).map(
         lambda ok: StakeActivation(**ok),
     )
@@ -209,6 +240,7 @@ def get_transaction(
     timeout: float = 5,
     proxy: str | None = None,
 ) -> Result[dict[str, object] | None]:
+    """Return transaction details for a given signature."""
     if max_supported_transaction_version is not None:
         params = [signature, {"maxSupportedTransactionVersion": max_supported_transaction_version, "encoding": encoding}]
     else:

mm_sol/spl_token.py

@@ -1,3 +1,5 @@
+"""SPL token balance and metadata queries via Solana RPC."""
+
 from mm_result import Result
 from solana.exceptions import SolanaRpcException
 from solana.rpc.core import RPCException
@@ -14,6 +16,7 @@ async def get_balance(
     timeout: float = 5,
     proxy: str | None = None,
 ) -> Result[int]:
+    """Return the token balance in smallest units for the owner's associated token account."""
     response = None
     try:
         client = get_async_client(node, proxy=proxy, timeout=timeout)
@@ -38,6 +41,7 @@ async def get_balance(
 
 
 async def get_decimals(node: str, token: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
+    """Return the number of decimals for a token mint."""
     response = None
     try:
         client = get_async_client(node, proxy=proxy, timeout=timeout)

mm_sol/transfer.py

@@ -1,3 +1,5 @@
+"""SOL and SPL token transfer operations."""
+
 import pydash
 from mm_result import Result
 from pydantic import BaseModel
@@ -27,6 +29,7 @@ async def transfer_token(
     timeout: float = 10,
     create_token_account_if_not_exists: bool = True,
 ) -> Result[Signature]:
+    """Transfer SPL tokens, optionally creating the recipient's token account."""
     # TODO: try/except this function!!!
     acc = get_keypair(private_key)
     if not check_private_key(from_address, private_key):
@@ -74,6 +77,7 @@ async def transfer_sol(
     proxy: str | None = None,
     timeout: float = 10,
 ) -> Result[Signature]:
+    """Transfer SOL from one account to another."""
     acc = get_keypair(private_key)
     if not check_private_key(from_address, private_key):
         return Result.err("invalid_private_key")
@@ -93,12 +97,15 @@ async def transfer_sol(
 
 
 class SolTransferInfo(BaseModel):
+    """Parsed SOL transfer from a transaction's instructions."""
+
     source: str
     destination: str
     lamports: int
 
 
 def find_sol_transfers(node: str, tx_signature: str) -> Result[list[SolTransferInfo]]:
+    """Parse SOL transfer instructions from a transaction signature."""
     res = rpc_sync.get_transaction(node, tx_signature, encoding="jsonParsed")
     if res.is_err():
         return res  # type: ignore[return-value]
@@ -115,4 +122,4 @@ def find_sol_transfers(node: str, tx_signature: str) -> Result[list[SolTransferI
                     result.append(SolTransferInfo(source=source, destination=destination, lamports=lamports))
         return res.with_value(result)
     except Exception as e:
-        return Result.err(e, res.extra)
+        return Result.err(e, res.context)

mm_sol/utils.py

@@ -1,3 +1,5 @@
+"""Utility functions for creating Solana RPC clients and converting pubkeys."""
+
 from solana.rpc.api import Client
 from solana.rpc.async_api import AsyncClient
 from solana.rpc.commitment import Commitment
@@ -11,6 +13,7 @@ def get_client(
     proxy: str | None = None,
     timeout: float = 10,
 ) -> Client:
+    """Create a synchronous Solana RPC client."""
     return Client(endpoint, commitment=commitment, extra_headers=extra_headers, timeout=timeout, proxy=proxy)
 
 
@@ -21,10 +24,12 @@ def get_async_client(
     proxy: str | None = None,
     timeout: float = 10,
 ) -> AsyncClient:
+    """Create an asynchronous Solana RPC client."""
     return AsyncClient(endpoint, commitment=commitment, extra_headers=extra_headers, timeout=timeout, proxy=proxy)
 
 
 def pubkey(value: str | Pubkey) -> Pubkey:
+    """Convert a string or Pubkey to a Pubkey instance."""
     if isinstance(value, Pubkey):
         return value
     return Pubkey.from_string(value)

{mm_sol-0.7.4.dist-info → mm_sol-0.8.0.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: mm-sol
-Version: 0.7.4
-Requires-Python: >=3.13
+Version: 0.8.0
+Requires-Python: >=3.14
 Requires-Dist: base58~=2.1.1
 Requires-Dist: jinja2~=3.1.6
-Requires-Dist: mm-web3~=0.5.6
+Requires-Dist: mm-web3~=0.6.2
 Requires-Dist: mnemonic==0.21
 Requires-Dist: solana~=0.36.11
 Requires-Dist: typer~=0.21.1

mm_sol-0.8.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+mm_sol/__init__.py,sha256=fUeHKoD3cV4rOVWUrfNuugxIe71FcaWQkhnoyvtZrZg,54
+mm_sol/account.py,sha256=ytwiAzxvrjNryFaCDfIAuMMchluxm8gmNTX0w09HBVE,4538
+mm_sol/constants.py,sha256=2Lbzqi6hA_2edJ-AYgJszPGH2r9tOyXNWlabqE19uUM,106
+mm_sol/converters.py,sha256=NhgSEYdkz63Ph7G52vCCoSTlqD4ncO4xRtK7eXT_EQE,1797
+mm_sol/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_sol/retry.py,sha256=RILvfBtpHjDwacrX2aCdtSkAvLB9Cn59SoQa9Dv3VQE,3315
+mm_sol/rpc.py,sha256=o3PEx4at5JCZ4qKkZTMDozr4kt1ZKeGPBKeJxk2owFk,2768
+mm_sol/rpc_sync.py,sha256=XVs6vA1o5Y1I1MvMWv0ePDBcwVdj7rMWX7QJULfEB8Y,8531
+mm_sol/spl_token.py,sha256=yw-tIH-wbfrTf7WdjMr39ZbAO4Ip-T0wTd8YBP3K-0w,2159
+mm_sol/transfer.py,sha256=7roDEqE6qyUZCsw4J4MBMZwBlEVPTnls0vX5AupFEB0,4733
+mm_sol/utils.py,sha256=ZeTESNwYEcMfGl523WwnMwzWIGT-SEh5WsAz62kEIE8,1165
+mm_sol/cli/__init__.py,sha256=AoiQ74zt-QmDnw1wLOfMW5HLNtZrj6Ut9DExNQ0CLDA,32
+mm_sol/cli/calcs.py,sha256=jb6AnmXQDm3fgYxOhjmN5E6caCdBGkpm0IiN7WwWL00,2184
+mm_sol/cli/cli.py,sha256=-y2uvJAS__4pSK9z61R42pWcuGPBjV8dcb5z7SGbHdI,5457
+mm_sol/cli/cli_utils.py,sha256=UdRN-NTvxyJjWS3c2dzznK9TCg69ptP_3V3acgy3jfA,2471
+mm_sol/cli/validators.py,sha256=cMANe5jbMrw9Bb2PrCvciaKmEjWpYEykdice29x9f1s,2037
+mm_sol/cli/cmd/__init__.py,sha256=GYdoNv80KS2p7bCThuoRbhiLmIZW6ddPqPEFEx567nQ,35
+mm_sol/cli/cmd/balance_cmd.py,sha256=mEfpcL4LD3do9mwIwSXg-qz2gZ7YT32zYhDLSXx5cpw,2816
+mm_sol/cli/cmd/balances_cmd.py,sha256=MnZZNc6cSAneaDyTZ9BxZjUlUgRg1TG84RyGzd9HwCg,3072
+mm_sol/cli/cmd/example_cmd.py,sha256=8DM8Zbuj8FMzzd04ywfALXfzpYxvUy3sS-r5oj7vz3M,338
+mm_sol/cli/cmd/node_cmd.py,sha256=DukE_9VuoPEWxlberIRwZ9kUhXgbQv1n0xGsl-cc8kI,463
+mm_sol/cli/cmd/transfer_cmd.py,sha256=A1bfeUvFvU16SFfWt7i0FfswIhA-PH5fld4oHOQAI1w,12143
+mm_sol/cli/cmd/wallet/__init__.py,sha256=et8EPGCXsVukSYnO29E1Wn_O0_Sf8FKxc-09UuFL_gk,35
+mm_sol/cli/cmd/wallet/keypair_cmd.py,sha256=XsToFLoQjxbK4q9-UZZtLa7U7ZGBDS7-HMrWSyufhUA,676
+mm_sol/cli/cmd/wallet/mnemonic_cmd.py,sha256=XzCpmpaiKgrButhEmPe6Ww51Pmml_Q727654dU7i6Wo,784
+mm_sol/cli/examples/balances.toml,sha256=UxX5FXKhH1lwjniiOQW-hZP0C731W96o5-1V1yqg0cQ,350
+mm_sol/cli/examples/transfer.toml,sha256=-7inhWntAHKYqr0spmRYyNflUrYWscv_xMoWwytS61E,1623
+mm_sol-0.8.0.dist-info/METADATA,sha256=t6wCPNR7ZD5kVFn4xV_Pbb4r2jMSj5GTmdQM06f8q6o,252
+mm_sol-0.8.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mm_sol-0.8.0.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
+mm_sol-0.8.0.dist-info/RECORD,,

mm_sol-0.7.4.dist-info/RECORD

@@ -1,31 +0,0 @@
-mm_sol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/account.py,sha256=cVcxRQBuV_Gfm2WgQIwaYuAQijeIJqDDxLC22PN0XSs,3493
-mm_sol/constants.py,sha256=9XKF8Z2dyY6L82_Bm0_naSQp5U0mIaOeqbZNBj25D2E,27
-mm_sol/converters.py,sha256=rBxe3SIADZS8hG7TYl4FgjmvKH-ykaTmNbnWWQDiFZ4,1430
-mm_sol/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/retry.py,sha256=IjaKvIe13_kRkwUxEpgNaZ0MNAW9bSOW5H33BL8GNA4,2889
-mm_sol/rpc.py,sha256=TFgU6H5la7ctEgPyQ0CW8SxipCycx8FFCu1baR6F_mM,2473
-mm_sol/rpc_sync.py,sha256=ryS6ZuPrrZsfQUuizVHbgcr-IX_jS9hF4J4B1ya2FAU,7190
-mm_sol/spl_token.py,sha256=Bd5zXhlVhFd5n3WwunRoeM_yYo-0f1hNR7_1zww81A8,1944
-mm_sol/transfer.py,sha256=kfNGRjF4aNSLAyBdm0jHyCXENFTMwib4pqIhKRJGCCQ,4413
-mm_sol/utils.py,sha256=oD06NsMSMhN6lqsM6mSgLTtiKwA1uAsen9WR82ofRTE,923
-mm_sol/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/cli/calcs.py,sha256=lgXF5SJkwOEY2AjygBO9CxP-LpyvOWB7j5HQn6p-1tU,1765
-mm_sol/cli/cli.py,sha256=TxAAQ-QX9j9mG6d6el9SLYxF3QeIeWal7AdW_GTzPZQ,4723
-mm_sol/cli/cli_utils.py,sha256=1_ikUjwHkxJleNwhVLaI_-6m4JyCKZFH2WgvsZ5EGMk,1799
-mm_sol/cli/validators.py,sha256=DnK2C68MgceqQ6Zs90WZ6Co0LYMiNmhxZILX-2GKhZM,1401
-mm_sol/cli/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/cli/cmd/balance_cmd.py,sha256=6h7ryybMyegy8EsV1limWo2gcYL9_dczK9JRiHxHLzg,2452
-mm_sol/cli/cmd/balances_cmd.py,sha256=u8dSexKVVExC-5U-8vPUDFUBF2r-j-vsSmmOBM-Tsqc,2673
-mm_sol/cli/cmd/example_cmd.py,sha256=HFEjAPxIPAss3u--i3mLpvVttCkmY1Ps4aEfNLPp8bw,209
-mm_sol/cli/cmd/node_cmd.py,sha256=octbG9IwCUKyaFgGrPf_2MJlzHKncMQhGlyi-1rqw-E,339
-mm_sol/cli/cmd/transfer_cmd.py,sha256=6q5LbWWl6AvQI2u4kh3qMQpZndPkdturTn_1wgGflNo,11023
-mm_sol/cli/cmd/wallet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/cli/cmd/wallet/keypair_cmd.py,sha256=HndbANn2XbuHWxD-8ggKEGUK1OT1tjiVTtR5G6F8XFw,527
-mm_sol/cli/cmd/wallet/mnemonic_cmd.py,sha256=xT0wzBtj9IeJHvrzst0jFjXP4pj_k17JsKX_PBNjIO4,637
-mm_sol/cli/examples/balances.toml,sha256=UxX5FXKhH1lwjniiOQW-hZP0C731W96o5-1V1yqg0cQ,350
-mm_sol/cli/examples/transfer.toml,sha256=-7inhWntAHKYqr0spmRYyNflUrYWscv_xMoWwytS61E,1623
-mm_sol-0.7.4.dist-info/METADATA,sha256=qZbfGj2Wz16APhjeC5GVH2bxpllHii6GUT5BU9fzl1g,252
-mm_sol-0.7.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mm_sol-0.7.4.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
-mm_sol-0.7.4.dist-info/RECORD,,