mm-sol 0.6.2__py3-none-any.whl → 0.7.0__py3-none-any.whl

mm_sol/cli/calcs.py

@@ -1,31 +1,31 @@
-import mm_crypto_utils
-from mm_crypto_utils import Nodes, Proxies, VarInt
-from mm_std import Result
+from mm_cryptocurrency import Nodes, Proxies
+from mm_cryptocurrency.calcs import calc_expression_with_vars
+from mm_result import Result
 
 from mm_sol import retry
-from mm_sol.constants import SUFFIX_DECIMALS
+from mm_sol.constants import UNIT_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_sol_expression(expression: str, variables: dict[str, int] | None = None) -> int:
+    return calc_expression_with_vars(expression, variables, unit_decimals=UNIT_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_token_expression(expression: str, token_decimals: int, variables: dict[str, int] | None = None) -> int:
+    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]:
     value_expression = value_expression.lower()
-    var = None
+    variables: dict[str, int] | None = None
     if "balance" in value_expression:
         res = await retry.get_sol_balance(5, nodes, proxies, address=address)
         if res.is_err():
             return res
-        var = VarInt("balance", res.unwrap())
+        variables = {"balance": res.unwrap()}
 
-    value = calc_sol_expression(value_expression, var)
+    value = calc_sol_expression(value_expression, variables)
     if "balance" in value_expression:
         value = value - fee
     return Result.ok(value)
@@ -34,12 +34,12 @@ 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]:
-    var = None
+    variables: dict[str, int] | None = None
     value_expression = value_expression.lower()
     if "balance" in value_expression:
         res = await retry.get_token_balance(5, nodes, proxies, owner=owner, token=token)
         if res.is_err():
             return res
-        var = VarInt("balance", res.unwrap())
-    value = calc_token_expression(value_expression, token_decimals, var)
+        variables = {"balance": res.unwrap()}
+    value = calc_token_expression(value_expression, token_decimals, variables)
     return Result.ok(value)

mm_sol/cli/cli.py

@@ -3,8 +3,8 @@ from enum import Enum
 from pathlib import Path
 from typing import Annotated
 
+import mm_print
 import typer
-from mm_std import print_plain
 
 from mm_sol.account import PHANTOM_DERIVATION_PATH
 
@@ -24,7 +24,7 @@ app.add_typer(wallet_app, name="w", hidden=True)
 
 def version_callback(value: bool) -> None:
     if value:
-        print_plain(f"mm-sol: {cli_utils.get_version()}")
+        mm_print.plain(f"mm-sol: {cli_utils.get_version()}")
         raise typer.Exit
 
 

mm_sol/cli/cli_utils.py

@@ -2,10 +2,9 @@ import importlib.metadata
 import time
 from pathlib import Path
 
-import mm_crypto_utils
+import mm_print
 from loguru import logger
-from mm_crypto_utils import Nodes, Proxies
-from mm_std import BaseConfig, print_json
+from mm_cryptocurrency import CryptocurrencyConfig, Nodes, Proxies, random_node, random_proxy
 from pydantic import BaseModel
 from solders.signature import Signature
 
@@ -21,12 +20,12 @@ class BaseConfigParams(BaseModel):
     print_config_and_exit: bool
 
 
-def print_config(config: BaseConfig, exclude: set[str] | None = None, count: set[str] | None = None) -> None:
+def print_config(config: CryptocurrencyConfig, exclude: set[str] | None = None, count: set[str] | None = None) -> None:
     data = config.model_dump(exclude=exclude)
     if count:
         for k in count:
             data[k] = len(data[k])
-    print_json(data)
+    mm_print.json(data)
 
 
 def public_rpc_url(url: str | None) -> str:
@@ -48,8 +47,8 @@ def wait_confirmation(nodes: Nodes, proxies: Proxies, signature: Signature, log_
     count = 0
     while True:
         try:
-            node = mm_crypto_utils.random_node(nodes)
-            proxy = mm_crypto_utils.random_proxy(proxies)
+            node = random_node(nodes)
+            proxy = 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

mm_sol/cli/cmd/balance_cmd.py

@@ -1,7 +1,7 @@
 from decimal import Decimal
 
-import mm_crypto_utils
-from mm_std import print_json
+import mm_print
+from mm_cryptocurrency import fetch_proxies
 from pydantic import BaseModel, Field
 
 import mm_sol.retry
@@ -43,14 +43,14 @@ async def run(
 
     rpc_url = cli_utils.public_rpc_url(rpc_url)
 
-    proxies = await mm_crypto_utils.fetch_proxies_or_fatal(proxies_url) if proxies_url else None
+    proxies = (await fetch_proxies(proxies_url)).unwrap() if proxies_url else None
 
     # sol balance
     sol_balance_res = await retry.get_sol_balance(3, rpc_url, proxies, address=wallet_address)
     if sol_balance_res.is_ok():
         result.sol_balance = sol_balance_res.unwrap()
     else:
-        result.errors.append("sol_balance: " + sol_balance_res.unwrap_error())
+        result.errors.append("sol_balance: " + sol_balance_res.unwrap_err())
 
     # token balance
     if token_address:
@@ -59,15 +59,15 @@ async def run(
         if token_balance_res.is_ok():
             result.token_balance = token_balance_res.unwrap()
         else:
-            result.errors.append("token_balance: " + token_balance_res.unwrap_error())
+            result.errors.append("token_balance: " + token_balance_res.unwrap_err())
 
         decimals_res = await mm_sol.retry.get_token_decimals(3, rpc_url, proxies, token=token_address)
         if decimals_res.is_ok():
             result.token_decimals = decimals_res.unwrap()
         else:
-            result.errors.append("token_decimals: " + decimals_res.unwrap_error())
+            result.errors.append("token_decimals: " + decimals_res.unwrap_err())
 
     if lamport:
-        print_json(result)
+        mm_print.json(result)
     else:
-        print_json(result.to_human_readable())
+        mm_print.json(result.to_human_readable())

mm_sol/cli/cmd/balances_cmd.py

@@ -3,8 +3,8 @@ from decimal import Decimal
 from pathlib import Path
 from typing import Annotated, Any
 
-from mm_crypto_utils import ConfigValidators
-from mm_std import BaseConfig, fatal, print_json
+import mm_print
+from mm_cryptocurrency import ConfigValidators, CryptocurrencyConfig
 from pydantic import BeforeValidator, Field
 
 import mm_sol.retry
@@ -12,7 +12,7 @@ from mm_sol import converters, retry
 from mm_sol.cli.validators import Validators
 
 
-class Config(BaseConfig):
+class Config(CryptocurrencyConfig):
     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())]
@@ -35,14 +35,14 @@ 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():
-                fatal(f"Failed to get decimals for token {token_address}: {res.unwrap_error()}")
+                mm_print.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])
 
-    print_json(result)
+    mm_print.json(result)
 
 
 async def _get_token_balances(

mm_sol/cli/cmd/example_cmd.py

@@ -1,8 +1,8 @@
 from pathlib import Path
 
-from mm_std import pretty_print_toml
+import mm_print
 
 
 def run(module: str) -> None:
     example_file = Path(Path(__file__).parent.absolute(), "../examples", f"{module}.toml")
-    pretty_print_toml(example_file.read_text())
+    mm_print.toml(toml=example_file.read_text())

mm_sol/cli/cmd/node_cmd.py

@@ -1,4 +1,4 @@
-from mm_std import print_json
+import mm_print
 
 from mm_sol import rpc
 from mm_sol.cli import cli_utils
@@ -8,4 +8,4 @@ async def run(urls: list[str], proxy: str | None) -> None:
     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()
-    print_json(data=result)
+    mm_print.json(data=result)

mm_sol/cli/cmd/transfer_cmd.py

@@ -3,10 +3,14 @@ import sys
 from pathlib import Path
 from typing import Annotated
 
-import mm_crypto_utils
+import mm_print
 from loguru import logger
-from mm_crypto_utils import AddressToPrivate, Transfer
-from mm_std import BaseConfig, fatal, utc_now
+from mm_cryptocurrency import CryptocurrencyConfig
+from mm_cryptocurrency.account import PrivateKeyMap
+from mm_cryptocurrency.calcs import calc_decimal_expression
+from mm_cryptocurrency.log import init_loguru
+from mm_cryptocurrency.validators import Transfer
+from mm_std import utc_now
 from pydantic import AfterValidator, BeforeValidator, Field, model_validator
 from rich.console import Console
 from rich.live import Live
@@ -21,16 +25,16 @@ from mm_sol.cli.validators import Validators
 from mm_sol.converters import lamports_to_sol, to_token
 
 
-class Config(BaseConfig):
+class Config(CryptocurrencyConfig):
     nodes: Annotated[list[str], BeforeValidator(Validators.nodes())]
     transfers: Annotated[list[Transfer], BeforeValidator(Validators.sol_transfers())]
-    private_keys: Annotated[AddressToPrivate, BeforeValidator(Validators.sol_private_keys())]
+    private_keys: Annotated[PrivateKeyMap, BeforeValidator(Validators.sol_private_keys())]
     proxies: Annotated[list[str], Field(default_factory=list), BeforeValidator(Validators.proxies())]
     token: Annotated[str | None, AfterValidator(Validators.sol_address())] = None
     token_decimals: int = -1
     default_value: Annotated[str | None, AfterValidator(Validators.valid_sol_or_token_expression("balance"))] = None
     value_min_limit: Annotated[str | None, AfterValidator(Validators.valid_sol_or_token_expression())] = None
-    delay: Annotated[str | None, AfterValidator(Validators.valid_calc_decimal_value())] = None  # in seconds
+    delay: Annotated[str | None, AfterValidator(Validators.decimal_expression())] = 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
@@ -65,7 +69,7 @@ class Config(BaseConfig):
         if self.token:
             res = await mm_sol.retry.get_token_decimals(3, self.nodes, self.proxies, token=self.token)
             if res.is_err():
-                fatal(f"can't get decimals for token={self.token}, error={res.unwrap_error()}")
+                mm_print.fatal(f"can't get decimals for token={self.token}, error={res.unwrap_err()}")
             self.token_decimals = res.unwrap()
 
         return self
@@ -99,13 +103,13 @@ async def run(cmd_params: TransferCmdParams) -> None:
 
 
 async def _run_transfers(config: Config, cmd_params: TransferCmdParams) -> None:
-    mm_crypto_utils.init_logger(cmd_params.debug, config.log_debug, config.log_info)
+    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.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)
         if config.delay is not None and i < len(config.transfers) - 1:
-            delay_value = mm_crypto_utils.calc_decimal_value(config.delay)
+            delay_value = calc_decimal_expression(config.delay)
             logger.info(f"delay {delay_value} seconds")
             if not cmd_params.emulate:
                 await asyncio.sleep(float(delay_value))
@@ -132,7 +136,7 @@ async def _calc_value(transfer: Transfer, config: Config, transfer_sol_fee: int)
         )
     logger.debug(f"{transfer.log_prefix}: value={value_res.value_or_error()}")
     if value_res.is_err():
-        logger.info(f"{transfer.log_prefix}: calc value error, {value_res.unwrap_error()}")
+        logger.info(f"{transfer.log_prefix}: calc value error, {value_res.unwrap_err()}")
 
     return value_res.value
 
@@ -181,7 +185,7 @@ async def _send_tx(transfer: Transfer, value: int, config: Config) -> Signature
         )
 
     if res.is_err():
-        logger.info(f"{transfer.log_prefix}: tx error {res.unwrap_error()}")
+        logger.info(f"{transfer.log_prefix}: tx error {res.unwrap_err()}")
         return None
     return res.value
 

mm_sol/cli/cmd/wallet/keypair_cmd.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from mm_std import print_json
+import mm_print
 
 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_json({"public": public, "private_base58": private_base58, "private_arr": private_arr})
+    mm_print.json({"public": public, "private_base58": private_base58, "private_arr": private_arr})

mm_sol/cli/cmd/wallet/mnemonic_cmd.py

@@ -1,7 +1,7 @@
 from dataclasses import asdict
 from typing import Any
 
-from mm_std import print_json
+import mm_print
 
 from mm_sol.account import derive_accounts, generate_mnemonic
 
@@ -16,4 +16,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]
-    print_json(result)
+    mm_print.json(result)

mm_sol/cli/validators.py

@@ -1,9 +1,11 @@
 from collections.abc import Callable
 
-from mm_crypto_utils import AddressToPrivate, ConfigValidators, Transfer
+from mm_cryptocurrency import ConfigValidators
+from mm_cryptocurrency.account import PrivateKeyMap
+from mm_cryptocurrency.validators import Transfer
 
 from mm_sol.account import get_public_key, is_address
-from mm_sol.constants import SUFFIX_DECIMALS
+from mm_sol.constants import UNIT_DECIMALS
 
 
 class Validators(ConfigValidators):
@@ -20,17 +22,17 @@ class Validators(ConfigValidators):
         return ConfigValidators.transfers(is_address)
 
     @staticmethod
-    def sol_private_keys() -> Callable[[str], AddressToPrivate]:
+    def sol_private_keys() -> Callable[[str], PrivateKeyMap]:
         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)
+        return ConfigValidators.expression_with_vars(var_name, UNIT_DECIMALS)
 
     @staticmethod
     def valid_token_expression(var_name: str | None = None) -> Callable[[str], str]:
-        return ConfigValidators.valid_calc_int_expression(var_name, {"t": 6})
+        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 ConfigValidators.valid_calc_int_expression(var_name, SUFFIX_DECIMALS | {"t": 6})
+        return ConfigValidators.expression_with_vars(var_name, UNIT_DECIMALS | {"t": 6})

mm_sol/constants.py

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

mm_sol/retry.py

@@ -1,5 +1,5 @@
-from mm_crypto_utils import Nodes, Proxies, retry_with_node_and_proxy
-from mm_std import Result
+from mm_cryptocurrency import Nodes, Proxies, retry_with_node_and_proxy
+from mm_result import Result
 from solders.solders import Pubkey, Signature
 
 from mm_sol import rpc, spl_token, transfer

mm_sol/rpc.py

@@ -3,7 +3,8 @@ from collections.abc import Sequence
 from typing import Any
 
 import websockets
-from mm_std import Result, http_request
+from mm_http import http_request
+from mm_result import Result
 
 
 async def rpc_call(
@@ -23,17 +24,17 @@ async def rpc_call(
 async def _http_call(node: str, data: dict[str, object], timeout: float, proxy: str | None) -> Result[Any]:
     res = await http_request(node, method="POST", proxy=proxy, timeout=timeout, json=data)
     if res.is_err():
-        return res.to_err()
+        return res.to_result_err()
     try:
         parsed_body = res.parse_json_body()
         err = parsed_body.get("error", {}).get("message", "")
         if err:
-            return res.to_err(f"service_error: {err}")
+            return res.to_result_err(f"service_error: {err}")
         if "result" in parsed_body:
-            return res.to_ok(parsed_body["result"])
-        return res.to_err("unknown_response")
+            return res.to_result_ok(parsed_body["result"])
+        return res.to_result_err("unknown_response")
     except Exception as e:
-        return res.to_err(e)
+        return res.to_result_err(e)
 
 
 async def _ws_call(node: str, data: dict[str, object], timeout: float) -> Result[Any]:
@@ -55,7 +56,7 @@ async def _ws_call(node: str, data: dict[str, object], timeout: float) -> Result
         return Result.err(e, {"response": response})
 
 
-async def get_block_height(node: str, timeout: float = 10, proxy: str | None = None) -> Result[int]:
+async def get_block_height(node: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
     return await rpc_call(node=node, method="getBlockHeight", params=[], timeout=timeout, proxy=proxy)
 
 

mm_sol/rpc_sync.py

@@ -1,7 +1,8 @@
 from typing import Any
 
 import pydash
-from mm_std import Result, http_request_sync
+from mm_http import http_request_sync
+from mm_result import Result
 from pydantic import BaseModel, ConfigDict, Field
 
 DEFAULT_MAINNET_RPC = "https://api.mainnet-beta.solana.com"
@@ -79,7 +80,7 @@ def rpc_call(
     method: str,
     params: list[Any],
     id_: int = 1,
-    timeout: float = 10,
+    timeout: float = 5,
     proxy: str | None = None,
 ) -> Result[Any]:
     data = {"jsonrpc": "2.0", "method": method, "params": params, "id": id_}
@@ -92,50 +93,50 @@ def _http_call(node: str, data: dict[str, object], timeout: float, proxy: str |
     res = http_request_sync(node, method="POST", proxy=proxy, timeout=timeout, json=data)
     try:
         if res.is_err():
-            return res.to_err()
+            return res.to_result_err()
 
         json_body = res.parse_json_body()
         err = pydash.get(json_body, "error.message")
         if err:
-            return res.to_err(f"service_error: {err}")
+            return res.to_result_err(f"service_error: {err}")
         if "result" in json_body:
-            return res.to_ok(json_body["result"])
+            return res.to_result_ok(json_body["result"])
 
-        return res.to_err("unknown_response")
+        return res.to_result_err("unknown_response")
     except Exception as e:
-        return res.to_err(e)
+        return res.to_result_err(e)
 
 
-def get_balance(node: str, address: str, timeout: float = 10, proxy: str | None = None) -> Result[int]:
+def get_balance(node: str, address: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
     """Returns 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 = 10, proxy: str | None = None) -> Result[int]:
+def get_block_height(node: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
     """Returns balance in lamports"""
     return rpc_call(node=node, method="getBlockHeight", params=[], timeout=timeout, proxy=proxy)
 
 
-def get_slot(node: str, timeout: float = 10, proxy: str | None = None) -> Result[int]:
+def get_slot(node: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
     return rpc_call(node=node, method="getSlot", params=[], timeout=timeout, proxy=proxy)
 
 
-def get_epoch_info(node: str, epoch: int | None = None, timeout: float = 10, proxy: str | None = None) -> Result[EpochInfo]:
+def get_epoch_info(node: str, epoch: int | None = None, timeout: float = 5, proxy: str | None = None) -> Result[EpochInfo]:
     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 = 10, proxy: str | None = None) -> Result[bool]:
+def get_health(node: str, timeout: float = 5, proxy: str | None = None) -> Result[bool]:
     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 = 30, proxy: str | None = None) -> Result[list[ClusterNode]]:
+def get_cluster_nodes(node: str, timeout: float = 5, proxy: str | None = None) -> Result[list[ClusterNode]]:
     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 = 30, proxy: str | None = None) -> Result[list[VoteAccount]]:
+def get_vote_accounts(node: str, timeout: float = 5, proxy: str | None = None) -> Result[list[VoteAccount]]:
     res = rpc_call(node=node, method="getVoteAccounts", timeout=timeout, proxy=proxy, params=[])
     if res.is_err():
         return res
@@ -182,7 +183,7 @@ def get_vote_accounts(node: str, timeout: float = 30, proxy: str | None = None)
 def get_leader_scheduler(
     node: str,
     slot: int | None = None,
-    timeout: float = 10,
+    timeout: float = 5,
     proxy: str | None = None,
 ) -> Result[dict[str, list[int]]]:
     return rpc_call(
@@ -205,7 +206,7 @@ def get_transaction(
     signature: str,
     max_supported_transaction_version: int | None = None,
     encoding: str = "json",
-    timeout: float = 60,
+    timeout: float = 5,
     proxy: str | None = None,
 ) -> Result[dict[str, object] | None]:
     if max_supported_transaction_version is not None:

mm_sol/spl_token.py

@@ -1,4 +1,4 @@
-from mm_std import Result
+from mm_result import Result
 from solana.exceptions import SolanaRpcException
 from solana.rpc.core import RPCException
 from solders.solders import InvalidParamsMessage, Pubkey, get_associated_token_address

mm_sol/transfer.py

@@ -1,5 +1,5 @@
 import pydash
-from mm_std import Result
+from mm_result import Result
 from pydantic import BaseModel
 from solders.message import Message
 from solders.pubkey import Pubkey

mm_sol-0.7.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: mm-sol
+Version: 0.7.0
+Requires-Python: >=3.13
+Requires-Dist: base58~=2.1.1
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: mm-cryptocurrency~=0.4.7
+Requires-Dist: mnemonic==0.21
+Requires-Dist: socksio>=1.0.0
+Requires-Dist: solana~=0.36.7
+Requires-Dist: typer>=0.16.0

mm_sol-0.7.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+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=65VeibEB1FGJXVPzcGwIVK9UcbtIsnEhdmIWMhZAaxU,2899
+mm_sol/rpc.py,sha256=c5AtHygQD5xawqfrrqByNtdGsEAq3mFfC17sdM3y4lU,2478
+mm_sol/rpc_sync.py,sha256=bHK5vUramNxgA0v5BwSFNpzpiyKWSeBUW6Bu8tXV9W8,7195
+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=7t5iFWVQbZiObsEx_DgBc8E9PlS39fge_N1R_8OJEEk,1785
+mm_sol/cli/cli.py,sha256=TxAAQ-QX9j9mG6d6el9SLYxF3QeIeWal7AdW_GTzPZQ,4723
+mm_sol/cli/cli_utils.py,sha256=1Tg7jwFfYn9he-QS2vGBl9-MXwBRJRb1Xsjw004z1Iw,1823
+mm_sol/cli/validators.py,sha256=LtclH-fatMxYRC9v8v0f9HHTDV708TWseBgDEXPllg0,1431
+mm_sol/cli/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_sol/cli/cmd/balance_cmd.py,sha256=-GPBjs9PWdHUcNxV_CKpmns7kJUykeqeNcSbIrO6aoU,2462
+mm_sol/cli/cmd/balances_cmd.py,sha256=ROI6ozTNP3o4CVQ9Bsg9TqYw6QJp3DuWDLJ6eoHhl6A,2687
+mm_sol/cli/cmd/example_cmd.py,sha256=r_fBZyFHAs6OTHT7HnE18bh_SKz-ABrcX6_nytJyJDY,214
+mm_sol/cli/cmd/node_cmd.py,sha256=octbG9IwCUKyaFgGrPf_2MJlzHKncMQhGlyi-1rqw-E,339
+mm_sol/cli/cmd/transfer_cmd.py,sha256=Uk9dT__j0XoCMucFQuMw2e8OCkdR4GJGdLygq1926qM,11077
+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=333g2EkyYBDW7OWFGMIWVZGkdFQMMo0Ag-bg-BvS4Zg,349
+mm_sol/cli/examples/transfer.toml,sha256=kOCdmuwmhlOam4LVtlcYTKF0PoZYHWMlv9gWxNSXMOk,1624
+mm_sol-0.7.0.dist-info/METADATA,sha256=F33DL_8KIot3m93mLdCGyV8qDdbGaEh9M-GbXS5HVsw,291
+mm_sol-0.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_sol-0.7.0.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
+mm_sol-0.7.0.dist-info/RECORD,,

mm_sol-0.6.2.dist-info/METADATA

@@ -1,12 +0,0 @@
-Metadata-Version: 2.4
-Name: mm-sol
-Version: 0.6.2
-Requires-Python: >=3.12
-Requires-Dist: base58~=2.1.1
-Requires-Dist: jinja2>=3.1.6
-Requires-Dist: mm-crypto-utils>=0.3.6
-Requires-Dist: mnemonic==0.21
-Requires-Dist: socksio>=1.0.0
-Requires-Dist: solana~=0.36.6
-Requires-Dist: solders~=0.26.0
-Requires-Dist: typer>=0.15.2

mm_sol-0.6.2.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=WSpfz5_cq_8XbIrNFJGu9okwbfPTL00zsyR_k9-7O0o,29
-mm_sol/converters.py,sha256=rBxe3SIADZS8hG7TYl4FgjmvKH-ykaTmNbnWWQDiFZ4,1430
-mm_sol/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/retry.py,sha256=9ejCcrHbJFOcZVKdbUASynLs1YHw04VAIKGH8mIJ1OI,2894
-mm_sol/rpc.py,sha256=LhXrHIz58iOG2ES8m67ycBCwkJx-4pLBuDt6Hsq6OkM,2422
-mm_sol/rpc_sync.py,sha256=A06MTSFQ7UUJgm0fy4a6ipqqY2vdDwS07UGXkdrvqWw,7148
-mm_sol/spl_token.py,sha256=hEWVch17EdudlL_tj3ZInCa9wB0iK8hwwpFucmVi7Pc,1941
-mm_sol/transfer.py,sha256=6CXzeMe91JtG8SuTadYQ-DLHJFyskytmBItGVEPh7Os,4410
-mm_sol/utils.py,sha256=oD06NsMSMhN6lqsM6mSgLTtiKwA1uAsen9WR82ofRTE,923
-mm_sol/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/cli/calcs.py,sha256=TR-mWQWYyHPdJYi_rvqiebqBqRsXsaqaSdvwCoSax1g,1675
-mm_sol/cli/cli.py,sha256=0MflYgO-UzFdoaXFCIBuQ1Y6AOQUquX__AhSWOO64KY,4735
-mm_sol/cli/cli_utils.py,sha256=nFdY8tJFZxyssEBEFCc3VTNJt447e6vMnugx4GBPL4o,1840
-mm_sol/cli/validators.py,sha256=M_Rr7JoG3TUYTDAGkjQLDH6l9i9FOrSpss30KdY3UlM,1379
-mm_sol/cli/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/cli/cmd/balance_cmd.py,sha256=ot6X7gTSoMcjapVkAgDlA9Wyo4YeFBIRA7GLjTXsu98,2469
-mm_sol/cli/cmd/balances_cmd.py,sha256=XNNyU02mvSxPdfD3usxucNiiHagxSnLe1rKihj-ya78,2676
-mm_sol/cli/cmd/example_cmd.py,sha256=ZLTy1-cmapiCyYvjFInVE-pQCGKZzDgYKUhsOwtbSIY,234
-mm_sol/cli/cmd/node_cmd.py,sha256=o3YktYk4o_ya8srN_It2BITam4HlpFMK11ajYNTGuKA,350
-mm_sol/cli/cmd/transfer_cmd.py,sha256=8QMfqUcvS63V_AeEvlvsuIEZIv_ydrMtuCOr4LvcyoY,10922
-mm_sol/cli/cmd/wallet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_sol/cli/cmd/wallet/keypair_cmd.py,sha256=cRHVVTs9zNYmUozZ8ZlJoutn9V6r8I1AEHBrszR7dTE,538
-mm_sol/cli/cmd/wallet/mnemonic_cmd.py,sha256=IiON_fJT5AFfIr_E1LR6_iDYZ3c_jWCFc-wSYqk61V8,648
-mm_sol/cli/examples/balances.toml,sha256=333g2EkyYBDW7OWFGMIWVZGkdFQMMo0Ag-bg-BvS4Zg,349
-mm_sol/cli/examples/transfer.toml,sha256=kOCdmuwmhlOam4LVtlcYTKF0PoZYHWMlv9gWxNSXMOk,1624
-mm_sol-0.6.2.dist-info/METADATA,sha256=H01qTQ1WZUC-TNzgDPimXXZpIFZVVcf6CvuvmeE6UsQ,320
-mm_sol-0.6.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_sol-0.6.2.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
-mm_sol-0.6.2.dist-info/RECORD,,