mm-sol 0.5.4__py3-none-any.whl → 0.5.6__py3-none-any.whl

mm_sol/account.py

@@ -51,7 +51,7 @@ def derive_accounts(mnemonic: str, passphrase: str, derivation_path: str, limit:
                 index=i,
                 path=path,
                 address=str(keypair.pubkey()),
-                private_key=base58.b58encode(bytes(keypair.to_bytes_array())).decode("utf-8"),
+                private_key=base58.b58encode(bytes(keypair.to_bytes())).decode("utf-8"),
             )
         )
 
@@ -61,8 +61,8 @@ def derive_accounts(mnemonic: str, passphrase: str, derivation_path: str, limit:
 def generate_account() -> NewAccount:
     keypair = Keypair()
     public_key = str(keypair.pubkey())
-    private_key_base58 = base58.b58encode(bytes(keypair.to_bytes_array())).decode("utf-8")
-    private_key_arr = list(keypair.to_bytes_array())
+    private_key_base58 = base58.b58encode(bytes(keypair.to_bytes())).decode("utf-8")
+    private_key_arr = list(keypair.to_bytes())
     return NewAccount(public_key=public_key, private_key_base58=private_key_base58, private_key_arr=private_key_arr)
 
 
@@ -93,12 +93,12 @@ def get_public_key(private_key: str) -> str:
 
 def get_private_key_base58(private_key: str) -> str:
     keypair = get_keypair(private_key)
-    return base58.b58encode(bytes(keypair.to_bytes_array())).decode("utf-8")
+    return base58.b58encode(bytes(keypair.to_bytes())).decode("utf-8")
 
 
 def get_private_key_arr(private_key: str) -> list[int]:
     keypair = get_keypair(private_key)
-    return list(x for x in keypair.to_bytes_array())  # noqa: C400
+    return list(x for x in keypair.to_bytes())  # noqa: C400
 
 
 def get_private_key_arr_str(private_key: str) -> str:

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,
@@ -48,11 +63,43 @@ def get_token_balance(
             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)
+        if "could not find account" in str(e):
+            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)
+
+
+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 "could not find account" in str(e):
+            return Ok(0)
         return Err(e)
+
     except httpx.HTTPStatusError as e:
         return Err(f"http error: {e}")
     except SolanaRpcException as e:
@@ -84,3 +131,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.4.dist-info → mm_sol-0.5.6.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: mm-sol
-Version: 0.5.4
+Version: 0.5.6
 Requires-Python: >=3.12
 Requires-Dist: base58~=2.1.1
 Requires-Dist: jinja2>=3.1.6
-Requires-Dist: mm-crypto-utils>=0.2.8
+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: solders~=0.26.0
 Requires-Dist: typer>=0.15.2

{mm_sol-0.5.4.dist-info → mm_sol-0.5.6.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/account.py,sha256=9aDP5si-QJfSF8fz8K6geGUGh9GL83YJNkdU1qd4Xu8,4515
+mm_sol/async_rpc.py,sha256=VpAovAgtDT-5OmwGyT8b-Ky_EtrGPKENKxZGGnw3_D8,1406
+mm_sol/balance.py,sha256=5sSIQbipNUeB_Hn7piwrYt-PuSEf4ZKB8puUmC986iY,5112
 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.4.dist-info/METADATA,sha256=0-qHBRgp0VFOPh7HkO6FPW6qXOP5hx0EIhAm0mNJQQE,289
-mm_sol-0.5.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_sol-0.5.4.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
-mm_sol-0.5.4.dist-info/RECORD,,
+mm_sol-0.5.6.dist-info/METADATA,sha256=ZAo75jqkghH06Uqiw_8bIU79xwX3Y3En599R3R_9A_4,320
+mm_sol-0.5.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_sol-0.5.6.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
+mm_sol-0.5.6.dist-info/RECORD,,