mm-sol 0.6.1__tar.gz → 0.6.3__tar.gz

{mm_sol-0.6.1 → mm_sol-0.6.3}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: mm-sol
-Version: 0.6.1
+Version: 0.6.3
 Requires-Python: >=3.12
 Requires-Dist: base58~=2.1.1
+Requires-Dist: h11>=0.16.0
 Requires-Dist: jinja2>=3.1.6
-Requires-Dist: mm-crypto-utils>=0.3.4
+Requires-Dist: mm-crypto-utils>=0.3.7
 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
+Requires-Dist: typer>=0.15.3

{mm_sol-0.6.1 → mm_sol-0.6.3}/pyproject.toml

@@ -1,17 +1,18 @@
 [project]
 name = "mm-sol"
-version = "0.6.1"
+version = "0.6.3"
 description = ""
 requires-python = ">=3.12"
 dependencies = [
-    "mm-crypto-utils>=0.3.4",
+    "mm-crypto-utils>=0.3.7",
     "solana~=0.36.6",
     "solders~=0.26.0",
     "base58~=2.1.1",
     "mnemonic==0.21",
-    "typer>=0.15.2",
+    "typer>=0.15.3",
     "jinja2>=3.1.6",
     "socksio>=1.0.0",
+    "h11>=0.16.0", # secure fix, remove when solana updated
 ]
 [project.scripts]
 mm-sol = "mm_sol.cli.cli:app"
@@ -24,7 +25,7 @@ build-backend = "hatchling.build"
 dev-dependencies = [
     "pytest~=8.3.5",
     "pytest-xdist~=3.6.1",
-    "ruff~=0.11.6",
+    "ruff~=0.11.9",
     "pip-audit~=2.9.0",
     "bandit~=1.8.3",
     "mypy~=1.15.0",

{mm_sol-0.6.1 → mm_sol-0.6.3}/src/mm_sol/cli/cmd/node_cmd.py

@@ -7,5 +7,5 @@ from mm_sol.cli import cli_utils
 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)).ok_or_error()
+        result[url] = (await rpc.get_block_height(url, proxy=proxy, timeout=10)).value_or_error()
     print_json(data=result)

{mm_sol-0.6.1 → mm_sol-0.6.3}/src/mm_sol/cli/cmd/transfer_cmd.py

@@ -130,7 +130,7 @@ async def _calc_value(transfer: Transfer, config: Config, transfer_sol_fee: int)
             proxies=config.proxies,
             fee=transfer_sol_fee,
         )
-    logger.debug(f"{transfer.log_prefix}: value={value_res.ok_or_error()}")
+    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()}")
 
@@ -256,11 +256,11 @@ async def _print_balances(config: Config) -> None:
 
 async def _get_sol_balance_str(address: str, config: Config) -> str:
     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))).ok_or_error()
+    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:
     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)
-    return res.map(lambda ok: str(to_token(ok, config.token_decimals, ndigits=config.round_ndigits))).ok_or_error()
+    return res.map(lambda ok: str(to_token(ok, config.token_decimals, ndigits=config.round_ndigits))).value_or_error()

{mm_sol-0.6.1 → mm_sol-0.6.3}/src/mm_sol/rpc.py

@@ -23,17 +23,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_result()
+        return res.to_err()
     try:
         parsed_body = res.parse_json_body()
         err = parsed_body.get("error", {}).get("message", "")
         if err:
-            return res.to_err_result(f"service_error: {err}")
+            return res.to_err(f"service_error: {err}")
         if "result" in parsed_body:
-            return res.to_ok_result(parsed_body["result"])
-        return res.to_err_result("unknown_response")
+            return res.to_ok(parsed_body["result"])
+        return res.to_err("unknown_response")
     except Exception as e:
-        return res.to_err_result(e)
+        return res.to_err(e)
 
 
 async def _ws_call(node: str, data: dict[str, object], timeout: float) -> Result[Any]:
@@ -55,7 +55,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.1 → mm_sol-0.6.3}/src/mm_sol/rpc_sync.py

@@ -79,7 +79,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 +92,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_result()
+            return res.to_err()
 
         json_body = res.parse_json_body()
         err = pydash.get(json_body, "error.message")
         if err:
-            return res.to_err_result(f"service_error: {err}")
+            return res.to_err(f"service_error: {err}")
         if "result" in json_body:
-            return res.to_ok_result(json_body["result"])
+            return res.to_ok(json_body["result"])
 
-        return res.to_err_result("unknown_response")
+        return res.to_err("unknown_response")
     except Exception as e:
-        return res.to_err_result(e)
+        return res.to_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 +182,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 +205,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: