mm-sol 0.5.3__py3-none-any.whl → 0.5.5__py3-none-any.whl

mm_sol/async_rpc.py

@@ -0,0 +1,42 @@
+from typing import Any
+
+from mm_std import Result, ahr
+
+
+async def rpc_call(
+    *,
+    node: str,
+    method: str,
+    params: list[Any],
+    id_: int = 1,
+    timeout: float = 10,
+    proxy: str | None = None,
+) -> Result[Any]:
+    data = {"jsonrpc": "2.0", "method": method, "params": params, "id": id_}
+    if node.startswith("http"):
+        return await _http_call(node, data, timeout, proxy)
+    raise NotImplementedError("ws is not implemented")
+
+
+async def _http_call(node: str, data: dict[str, object], timeout: float, proxy: str | None) -> Result[Any]:
+    res = await ahr(node, method="POST", proxy=proxy, timeout=timeout, params=data, json_params=True)
+    try:
+        if res.is_error():
+            return res.to_err_result()
+
+        err = res.json.get("error", {}).get("message", "")
+        if err:
+            return res.to_err_result(f"service_error: {err}")
+        if "result" in res.json:
+            return res.to_ok_result(res.json["result"])
+
+        return res.to_err_result("unknown_response")
+    except Exception as e:
+        return res.to_err_result(f"exception: {e!s}")
+
+
+async def get_balance(node: str, address: str, timeout: float = 10, proxy: str | None = None) -> Result[int]:
+    """Returns balance in lamports"""
+    return (await rpc_call(node=node, method="getBalance", params=[address], timeout=timeout, proxy=proxy)).and_then(
+        lambda r: r["value"]
+    )

mm_sol/balance.py

@@ -7,16 +7,20 @@ from solders.pubkey import Pubkey
 from solders.rpc.errors import InvalidParamsMessage
 from spl.token.instructions import get_associated_token_address
 
-from mm_sol import rpc
-from mm_sol.utils import get_client
+from mm_sol import async_rpc, rpc
+from mm_sol.utils import get_async_client, get_client
 
 
-def get_sol_balance(node: str, address: str, timeout: int = 10, proxy: str | None = None) -> Result[int]:
+def get_sol_balance(node: str, address: str, timeout: float = 10, proxy: str | None = None) -> Result[int]:
     return rpc.get_balance(node, address, timeout, proxy)
 
 
+async def get_sol_balance_async(node: str, address: str, timeout: float = 10, proxy: str | None = None) -> Result[int]:
+    return await async_rpc.get_balance(node, address, timeout, proxy)
+
+
 def get_sol_balance_with_retries(
-    nodes: Nodes, address: str, retries: int, timeout: int = 10, proxies: Proxies = None
+    nodes: Nodes, address: str, retries: int, timeout: float = 10, proxies: Proxies = None
 ) -> Result[int]:
     res: Result[int] = Err("not started yet")
     for _ in range(retries):
@@ -26,6 +30,17 @@ def get_sol_balance_with_retries(
     return res
 
 
+async def get_sol_balance_with_retries_async(
+    nodes: Nodes, address: str, retries: int, timeout: float = 10, proxies: Proxies = None
+) -> Result[int]:
+    res: Result[int] = Err("not started yet")
+    for _ in range(retries):
+        res = await get_sol_balance_async(random_node(nodes), address, timeout=timeout, proxy=random_proxy(proxies))
+        if res.is_ok():
+            return res
+    return res
+
+
 def get_token_balance(
     node: str,
     owner_address: str,
@@ -61,6 +76,41 @@ def get_token_balance(
         return Err(e)
 
 
+async def get_token_balance_async(
+    node: str,
+    owner_address: str,
+    token_mint_address: str,
+    token_account: str | None = None,
+    timeout: float = 10,
+    proxy: str | None = None,
+) -> Result[int]:
+    try:
+        client = get_async_client(node, proxy=proxy, timeout=timeout)
+        if not token_account:
+            token_account = str(
+                get_associated_token_address(Pubkey.from_string(owner_address), Pubkey.from_string(token_mint_address))
+            )
+
+        res = await client.get_token_account_balance(Pubkey.from_string(token_account))
+
+        # Sometimes it not raise an error, but it returns this :(
+        if isinstance(res, InvalidParamsMessage) and "could not find account" in res.message:
+            return Ok(0)
+        return Ok(int(res.value.amount), data=res.to_json())
+    except RPCException as e:
+        if len(e.args) > 1:
+            s = e.args[0]
+            if isinstance(s, InvalidParamsMessage) and "could not find account" in s.message:
+                return Ok(0)
+        return Err(e)
+    except httpx.HTTPStatusError as e:
+        return Err(f"http error: {e}")
+    except SolanaRpcException as e:
+        return Err(e.error_msg)
+    except Exception as e:
+        return Err(e)
+
+
 def get_token_balance_with_retries(
     nodes: Nodes,
     owner_address: str,
@@ -84,3 +134,28 @@ def get_token_balance_with_retries(
             return res
 
     return res
+
+
+async def get_token_balance_with_retries_async(
+    nodes: Nodes,
+    owner_address: str,
+    token_mint_address: str,
+    retries: int,
+    token_account: str | None = None,
+    timeout: float = 10,
+    proxies: Proxies = None,
+) -> Result[int]:
+    res: Result[int] = Err("not started yet")
+    for _ in range(retries):
+        res = await get_token_balance_async(
+            random_node(nodes),
+            owner_address,
+            token_mint_address,
+            token_account,
+            timeout=timeout,
+            proxy=random_proxy(proxies),
+        )
+        if res.is_ok():
+            return res
+
+    return res

mm_sol/rpc.py

@@ -78,7 +78,7 @@ def rpc_call(
     method: str,
     params: list[Any],
     id_: int = 1,
-    timeout: int = 10,
+    timeout: float = 10,
     proxy: str | None = None,
 ) -> Result[Any]:
     data = {"jsonrpc": "2.0", "method": method, "params": params, "id": id_}
@@ -87,7 +87,7 @@ def rpc_call(
     raise NotImplementedError("ws is not implemented")
 
 
-def _http_call(node: str, data: dict[str, object], timeout: int, proxy: str | None) -> Result[Any]:
+def _http_call(node: str, data: dict[str, object], timeout: float, proxy: str | None) -> Result[Any]:
     res = hr(node, method="POST", proxy=proxy, timeout=timeout, params=data, json_params=True)
     try:
         if res.is_error():
@@ -104,38 +104,38 @@ def _http_call(node: str, data: dict[str, object], timeout: int, proxy: str | No
         return res.to_err_result(f"exception: {e!s}")
 
 
-def get_balance(node: str, address: str, timeout: int = 10, proxy: str | None = None) -> Result[int]:
+def get_balance(node: str, address: str, timeout: float = 10, proxy: str | None = None) -> Result[int]:
     """Returns balance in lamports"""
     return rpc_call(node=node, method="getBalance", params=[address], timeout=timeout, proxy=proxy).and_then(lambda r: r["value"])
 
 
-def get_block_height(node: str, timeout: int = 10, proxy: str | None = None) -> Result[int]:
+def get_block_height(node: str, timeout: float = 10, 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: int = 10, proxy: str | None = None) -> Result[int]:
+def get_slot(node: str, timeout: float = 10, 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: int = 10, proxy: str | None = None) -> Result[EpochInfo]:
+def get_epoch_info(node: str, epoch: int | None = None, timeout: float = 10, proxy: str | None = None) -> Result[EpochInfo]:
     params = [epoch] if epoch else []
     return rpc_call(node=node, method="getEpochInfo", params=params, timeout=timeout, proxy=proxy).and_then(
         lambda r: EpochInfo(**r),
     )
 
 
-def get_health(node: str, timeout: int = 10, proxy: str | None = None) -> Result[bool]:
+def get_health(node: str, timeout: float = 10, proxy: str | None = None) -> Result[bool]:
     return rpc_call(node=node, method="getHealth", params=[], timeout=timeout, proxy=proxy).and_then(lambda r: r == "ok")
 
 
-def get_cluster_nodes(node: str, timeout: int = 30, proxy: str | None = None) -> Result[list[ClusterNode]]:
+def get_cluster_nodes(node: str, timeout: float = 30, proxy: str | None = None) -> Result[list[ClusterNode]]:
     return rpc_call(node=node, method="getClusterNodes", timeout=timeout, proxy=proxy, params=[]).and_then(
         lambda r: [ClusterNode(**n) for n in r],
     )
 
 
-def get_vote_accounts(node: str, timeout: int = 30, proxy: str | None = None) -> Result[list[VoteAccount]]:
+def get_vote_accounts(node: str, timeout: float = 30, 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: int = 30, proxy: str | None = None) ->
 def get_leader_scheduler(
     node: str,
     slot: int | None = None,
-    timeout: int = 10,
+    timeout: float = 10,
     proxy: str | None = None,
 ) -> Result[dict[str, list[int]]]:
     return rpc_call(
@@ -194,7 +194,7 @@ def get_leader_scheduler(
     )
 
 
-def get_block_production(node: str, timeout: int = 60, proxy: str | None = None) -> Result[BlockProduction]:
+def get_block_production(node: str, timeout: float = 60, proxy: str | None = None) -> Result[BlockProduction]:
     res = rpc_call(node=node, method="getBlockProduction", timeout=timeout, proxy=proxy, params=[])
     if res.is_err():
         return res
@@ -211,7 +211,7 @@ def get_block_production(node: str, timeout: int = 60, proxy: str | None = None)
         return Err(e, data=res.data)
 
 
-def get_stake_activation(node: str, address: str, timeout: int = 60, proxy: str | None = None) -> Result[StakeActivation]:
+def get_stake_activation(node: str, address: str, timeout: float = 60, proxy: str | None = None) -> Result[StakeActivation]:
     return rpc_call(node=node, method="getStakeActivation", timeout=timeout, proxy=proxy, params=[address]).and_then(
         lambda ok: StakeActivation(**ok),
     )
@@ -222,7 +222,7 @@ def get_transaction(
     signature: str,
     max_supported_transaction_version: int | None = None,
     encoding: str = "json",
-    timeout: int = 60,
+    timeout: float = 60,
     proxy: str | None = None,
 ) -> Result[dict[str, object] | None]:
     if max_supported_transaction_version is not None:

mm_sol/utils.py

@@ -1,4 +1,5 @@
 from solana.rpc.api import Client
+from solana.rpc.async_api import AsyncClient
 from solana.rpc.commitment import Commitment
 from solders.pubkey import Pubkey
 
@@ -13,6 +14,16 @@ def get_client(
     return Client(endpoint, commitment=commitment, extra_headers=extra_headers, timeout=timeout, proxy=proxy)
 
 
+def get_async_client(
+    endpoint: str,
+    commitment: Commitment | None = None,
+    extra_headers: dict[str, str] | None = None,
+    proxy: str | None = None,
+    timeout: float = 10,
+) -> AsyncClient:
+    return AsyncClient(endpoint, commitment=commitment, extra_headers=extra_headers, timeout=timeout, proxy=proxy)
+
+
 def pubkey(value: str | Pubkey) -> Pubkey:
     if isinstance(value, Pubkey):
         return value

mm_sol-0.5.5.dist-info/METADATA

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

{mm_sol-0.5.3.dist-info → mm_sol-0.5.5.dist-info}/RECORD

@@ -1,15 +1,16 @@
 mm_sol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mm_sol/account.py,sha256=0pjvNxwhpmDHoXY3oTY2fNlQHoWPmlS77r8JcP8lAy4,4545
-mm_sol/balance.py,sha256=qpjYkcZveyyBy1dSDI-bWlpkEtEoz7h68mhti_gqIRA,2803
+mm_sol/async_rpc.py,sha256=VpAovAgtDT-5OmwGyT8b-Ky_EtrGPKENKxZGGnw3_D8,1406
+mm_sol/balance.py,sha256=cMn9y0StOUwQM3Je4so6AoFCy3lS0JpaiEk-TnUp0Q4,5321
 mm_sol/block.py,sha256=4Lc4TANgpGvPflVumC9MR-3vIl1dedGyci3cgzczuds,1794
 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/rpc.py,sha256=TspD_KZQp_KJDQzRknxaT8DR03okok26UWDQWF7Zflg,8031
+mm_sol/rpc.py,sha256=Tw7THbU0lShjTGNGe4-Mc6q1U5E2dgjY2LIfrMTSfeA,8057
 mm_sol/solana_cli.py,sha256=ig3OoTvmkrl7MFQSZjRHIraLSmtse0_9kn5Nsw8_zb0,8258
 mm_sol/token.py,sha256=O8z3UE3iZGYLWw8fnd9weYMcoQO0m88noqbRO_jntGg,1092
 mm_sol/transfer.py,sha256=taf2NTLpo-bxISeaILARXEGLldUvqvP-agp5IDva7Hw,5825
-mm_sol/utils.py,sha256=NE0G564GiT9d7rW_lPPxUb1eq62WiXh28xtvtzNQIqw,556
+mm_sol/utils.py,sha256=oD06NsMSMhN6lqsM6mSgLTtiKwA1uAsen9WR82ofRTE,923
 mm_sol/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mm_sol/cli/calcs.py,sha256=-r9RlsQyOziTDf84uIsvTgZmsUdNrVeazu3vTj9hhNA,1887
 mm_sol/cli/cli.py,sha256=a28Cy1X2bRSIAAJu2HHoPoTJYOPvff-anVcL0BJnwRI,4610
@@ -26,7 +27,7 @@ mm_sol/cli/cmd/wallet/keypair_cmd.py,sha256=cRHVVTs9zNYmUozZ8ZlJoutn9V6r8I1AEHBr
 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.5.3.dist-info/METADATA,sha256=yDRwPlvuDfTn851BK9GJ8_nM5SUOH-MVskhVkVFNweM,290
-mm_sol-0.5.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_sol-0.5.3.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
-mm_sol-0.5.3.dist-info/RECORD,,
+mm_sol-0.5.5.dist-info/METADATA,sha256=90sfCL0vDIivEZTDRLHZGgu9leQSarrcyLQq3Th-yxo,289
+mm_sol-0.5.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_sol-0.5.5.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
+mm_sol-0.5.5.dist-info/RECORD,,

mm_sol-0.5.3.dist-info/METADATA

@@ -1,11 +0,0 @@
-Metadata-Version: 2.4
-Name: mm-sol
-Version: 0.5.3
-Requires-Python: >=3.12
-Requires-Dist: base58~=2.1.1
-Requires-Dist: jinja2>=3.1.5
-Requires-Dist: mm-crypto-utils>=0.2.6
-Requires-Dist: mnemonic==0.21
-Requires-Dist: solana~=0.36.5
-Requires-Dist: solders~=0.23.0
-Requires-Dist: typer>=0.15.1