mm-sol 0.6.2__tar.gz → 0.7.0__tar.gz

mm_sol-0.7.0/PKG-INFO

@@ -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.6.2 → mm_sol-0.7.0}/justfile

@@ -23,8 +23,10 @@ lint-fix: format
     uv run ruff check --fix src tests
 
 audit:
-    uv run pip-audit
-    uv run bandit -r -c "pyproject.toml" src
+    uv export --no-dev --all-extras --format requirements-txt --no-emit-project > requirements.txt
+    uv run pip-audit -r requirements.txt --disable-pip
+    rm requirements.txt
+    uv run bandit --silent --recursive --configfile "pyproject.toml" src
 
 publish: build
     git diff-index --quiet HEAD

{mm_sol-0.6.2 → mm_sol-0.7.0}/pyproject.toml

@@ -1,15 +1,14 @@
 [project]
 name = "mm-sol"
-version = "0.6.2"
+version = "0.7.0"
 description = ""
-requires-python = ">=3.12"
+requires-python = ">=3.13"
 dependencies = [
-    "mm-crypto-utils>=0.3.6",
-    "solana~=0.36.6",
-    "solders~=0.26.0",
+    "mm-cryptocurrency~=0.4.7",
+    "solana~=0.36.7",
     "base58~=2.1.1",
     "mnemonic==0.21",
-    "typer>=0.15.2",
+    "typer>=0.16.0",
     "jinja2>=3.1.6",
     "socksio>=1.0.0",
 ]
@@ -22,13 +21,14 @@ build-backend = "hatchling.build"
 
 [tool.uv]
 dev-dependencies = [
-    "pytest~=8.3.5",
-    "pytest-xdist~=3.6.1",
-    "ruff~=0.11.6",
+    "pytest~=8.4.0",
+    "pytest-asyncio~=1.0.0",
+    "pytest-xdist~=3.7.0",
+    "ruff~=0.11.13",
     "pip-audit~=2.9.0",
     "bandit~=1.8.3",
-    "mypy~=1.15.0",
-    "pytest-asyncio~=0.26.0",
+    "mypy~=1.16.0",
+    "python-dotenv>=1.1.0",
 ]
 
 [tool.mypy]

{mm_sol-0.6.2 → mm_sol-0.7.0}/src/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-0.6.2 → mm_sol-0.7.0}/src/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-0.6.2 → mm_sol-0.7.0}/src/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-0.6.2 → mm_sol-0.7.0}/src/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-0.6.2 → mm_sol-0.7.0}/src/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-0.6.2 → mm_sol-0.7.0}/src/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-0.6.2 → mm_sol-0.7.0}/src/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-0.6.2 → mm_sol-0.7.0}/src/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-0.6.2 → mm_sol-0.7.0}/src/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-0.6.2 → mm_sol-0.7.0}/src/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-0.6.2 → mm_sol-0.7.0}/src/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-0.7.0/src/mm_sol/constants.py

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

{mm_sol-0.6.2 → mm_sol-0.7.0}/src/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-0.6.2 → mm_sol-0.7.0}/src/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-0.6.2 → mm_sol-0.7.0}/src/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-0.6.2 → mm_sol-0.7.0}/src/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-0.6.2 → mm_sol-0.7.0}/src/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