mm-sol 0.5.9__py3-none-any.whl → 0.6.0__py3-none-any.whl

mm_sol/transfer.py

@@ -1,22 +1,54 @@
-import mm_crypto_utils
 import pydash
-from mm_crypto_utils import Nodes, Proxies
-from mm_std import Err, Ok, Result
+from mm_crypto_utils import Nodes, Proxies, retry_with_node_and_proxy
+from mm_std import Result
 from pydantic import BaseModel
 from solders.message import Message
 from solders.pubkey import Pubkey
 from solders.signature import Signature
 from solders.system_program import TransferParams, transfer
 from solders.transaction import Transaction
-from spl.token.client import Token
+from spl.token.async_client import AsyncToken
 from spl.token.constants import TOKEN_PROGRAM_ID
 from spl.token.instructions import get_associated_token_address
 
-from mm_sol import rpc, utils
+from mm_sol import rpc_sync, utils
 from mm_sol.account import check_private_key, get_keypair
 
 
-def transfer_token(
+async def transfer_token_with_retries(
+    retries: int,
+    nodes: Nodes,
+    proxies: Proxies,
+    *,
+    token_mint_address: str | Pubkey,
+    from_address: str | Pubkey,
+    private_key: str,
+    to_address: str | Pubkey,
+    amount: int,  # smallest unit
+    decimals: int,
+    timeout: float = 10,
+    create_token_account_if_not_exists: bool = True,
+) -> Result[Signature]:
+    return await retry_with_node_and_proxy(
+        retries,
+        nodes,
+        proxies,
+        lambda node, proxy: transfer_token(
+            node=node,
+            token_mint_address=token_mint_address,
+            from_address=from_address,
+            private_key=private_key,
+            to_address=to_address,
+            amount=amount,
+            decimals=decimals,
+            proxy=proxy,
+            timeout=timeout,
+            create_token_account_if_not_exists=create_token_account_if_not_exists,
+        ),
+    )
+
+
+async def transfer_token(
     *,
     node: str,
     token_mint_address: str | Pubkey,
@@ -29,73 +61,71 @@ def transfer_token(
     timeout: float = 10,
     create_token_account_if_not_exists: bool = True,
 ) -> Result[Signature]:
+    # TODO: try/except this function!!!
     acc = get_keypair(private_key)
     if not check_private_key(from_address, private_key):
-        return Err("invalid_private_key")
+        return Result.failure("invalid_private_key")
 
     from_address = utils.pubkey(from_address)
     token_mint_address = utils.pubkey(token_mint_address)
     to_address = utils.pubkey(to_address)
 
-    client = utils.get_client(node, proxy=proxy, timeout=timeout)
-    token_client = Token(conn=client, pubkey=token_mint_address, program_id=TOKEN_PROGRAM_ID, payer=acc)
+    client = utils.get_async_client(node, proxy=proxy, timeout=timeout)
+    token_client = AsyncToken(conn=client, pubkey=token_mint_address, program_id=TOKEN_PROGRAM_ID, payer=acc)
 
     recipient_token_account = get_associated_token_address(to_address, token_mint_address, token_program_id=TOKEN_PROGRAM_ID)
     from_token_account = get_associated_token_address(from_address, token_mint_address, token_program_id=TOKEN_PROGRAM_ID)
-    data: list[object] = []
+    logs: list[object] = []
 
-    account_info_res = client.get_account_info(recipient_token_account)
+    account_info_res = await client.get_account_info(recipient_token_account)
     if account_info_res.value is None:
         if create_token_account_if_not_exists:
             create_account_res = token_client.create_associated_token_account(to_address, skip_confirmation=False)
-            data.append(create_account_res)
+            logs.append(create_account_res)
         else:
-            return Err("no_token_account")
+            return Result.failure("no_token_account")
 
-    res = token_client.transfer_checked(
+    res = await token_client.transfer_checked(
         source=from_token_account,
         dest=recipient_token_account,
         owner=from_address,
         amount=amount,
         decimals=decimals,
+        multi_signers=None,
     )
-    data.append(res)
+    logs.append(res)
 
-    return Ok(res.value, data=data)
+    return Result.success(res.value, {"logs": logs})
 
 
-def transfer_token_with_retries(
-    *,
+async def transfer_sol_with_retries(
+    retries: int,
     nodes: Nodes,
-    token_mint_address: str | Pubkey,
-    from_address: str | Pubkey,
+    proxies: Proxies,
+    *,
+    from_address: str,
     private_key: str,
-    to_address: str | Pubkey,
-    amount: int,  # smallest unit
-    decimals: int,
-    proxies: Proxies = None,
+    to_address: str,
+    lamports: int,
     timeout: float = 10,
-    retries: int = 3,
 ) -> Result[Signature]:
-    res: Result[Signature] = Err("not started yet")
-    for _ in range(retries):
-        res = transfer_token(
-            node=mm_crypto_utils.random_node(nodes),
-            token_mint_address=token_mint_address,
+    return await retry_with_node_and_proxy(
+        retries,
+        nodes,
+        proxies,
+        lambda node, proxy: transfer_sol(
+            node=node,
+            proxy=proxy,
             from_address=from_address,
-            private_key=private_key,
             to_address=to_address,
-            amount=amount,
-            decimals=decimals,
-            proxy=mm_crypto_utils.random_proxy(proxies),
+            lamports=lamports,
+            private_key=private_key,
             timeout=timeout,
-        )
-        if res.is_ok():
-            return res
-    return res
+        ),
+    )
 
 
-def transfer_sol(
+async def transfer_sol(
     *,
     node: str,
     from_address: str,
@@ -107,46 +137,20 @@ def transfer_sol(
 ) -> Result[Signature]:
     acc = get_keypair(private_key)
     if not check_private_key(from_address, private_key):
-        return Err("invalid_private_key")
+        return Result.failure("invalid_private_key")
 
-    client = utils.get_client(node, proxy=proxy, timeout=timeout)
+    client = utils.get_async_client(node, proxy=proxy, timeout=timeout)
     data = None
     try:
         ixs = [transfer(TransferParams(from_pubkey=acc.pubkey(), to_pubkey=Pubkey.from_string(to_address), lamports=lamports))]
         msg = Message(ixs, acc.pubkey())
-        tx = Transaction([acc], msg, client.get_latest_blockhash().value.blockhash)
-        res = client.send_transaction(tx)
+        blockhash = await client.get_latest_blockhash()
+        tx = Transaction([acc], msg, blockhash.value.blockhash)
+        res = await client.send_transaction(tx)
         data = res.to_json()
-        return Ok(res.value, data=data)
+        return Result.success(res.value, {"response": data})
     except Exception as e:
-        return Err(e, data=data)
-
-
-def transfer_sol_with_retries(
-    *,
-    nodes: Nodes,
-    from_address: str,
-    private_key: str,
-    to_address: str,
-    lamports: int,
-    proxies: Proxies = None,
-    timeout: float = 10,
-    retries: int = 3,
-) -> Result[Signature]:
-    res: Result[Signature] = Err("not started yet")
-    for _ in range(retries):
-        res = transfer_sol(
-            node=mm_crypto_utils.random_node(nodes),
-            from_address=from_address,
-            private_key=private_key,
-            to_address=to_address,
-            lamports=lamports,
-            proxy=mm_crypto_utils.random_proxy(proxies),
-            timeout=timeout,
-        )
-        if res.is_ok():
-            return res
-    return res
+        return Result.failure(e, {"response": data})
 
 
 class SolTransferInfo(BaseModel):
@@ -156,8 +160,8 @@ class SolTransferInfo(BaseModel):
 
 
 def find_sol_transfers(node: str, tx_signature: str) -> Result[list[SolTransferInfo]]:
-    res = rpc.get_transaction(node, tx_signature, encoding="jsonParsed")
-    if res.is_err():
+    res = rpc_sync.get_transaction(node, tx_signature, encoding="jsonParsed")
+    if res.is_error():
         return res  # type: ignore[return-value]
     result = []
     try:
@@ -170,6 +174,6 @@ def find_sol_transfers(node: str, tx_signature: str) -> Result[list[SolTransferI
                 lamports = pydash.get(ix, "parsed.info.lamports")
                 if source and destination and lamports:
                     result.append(SolTransferInfo(source=source, destination=destination, lamports=lamports))
-        return Ok(result, data=res.data)
+        return Result.success(result, res.extra)
     except Exception as e:
-        return Err(e, res.data)
+        return Result.failure(e, res.extra)

{mm_sol-0.5.9.dist-info → mm_sol-0.6.0.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: mm-sol
-Version: 0.5.9
+Version: 0.6.0
 Requires-Python: >=3.12
 Requires-Dist: base58~=2.1.1
 Requires-Dist: jinja2>=3.1.6
-Requires-Dist: mm-crypto-utils>=0.2.15
+Requires-Dist: mm-crypto-utils>=0.3.3
+Requires-Dist: mm-std>=0.4.5
 Requires-Dist: mnemonic==0.21
 Requires-Dist: socksio>=1.0.0
 Requires-Dist: solana~=0.36.6

mm_sol-0.6.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+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/rpc.py,sha256=1rSGu8UKYug9-ScvK1zkaR_VdWUkXYJm2E8RTY2Hfhg,2982
+mm_sol/rpc_sync.py,sha256=w-xP3Hl_whBcZZJv5vw08oiB1GTPfbVRvsDjU_k-UTA,8122
+mm_sol/spl_token.py,sha256=NnTUWaefbvuZX9pDmRLHir2UUaiSWKZamyGsfKwQ2p4,2907
+mm_sol/transfer.py,sha256=CbUOFPjAoPf0KRPI-z5W0cSnTRFENbcNjLXDPKPrVBg,6049
+mm_sol/utils.py,sha256=oD06NsMSMhN6lqsM6mSgLTtiKwA1uAsen9WR82ofRTE,923
+mm_sol/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_sol/cli/calcs.py,sha256=uxnlGPU3UmDvZ567VLzcEyEWvM8CLcoTBt7YcILtaOA,1716
+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=0Rp6cUqfQLpNlqY6YtrpG-oYYz_llPhWpJkte804PL4,2495
+mm_sol/cli/cmd/balances_cmd.py,sha256=dArwI2oJaTMft73mN0EgDQWVSwRJmsAA0HyT8_GpBiA,2676
+mm_sol/cli/cmd/example_cmd.py,sha256=ZLTy1-cmapiCyYvjFInVE-pQCGKZzDgYKUhsOwtbSIY,234
+mm_sol/cli/cmd/node_cmd.py,sha256=xKjaMdv3_C4kePo-exjE4dQqUHtHWC4eHGROWLkWpS0,347
+mm_sol/cli/cmd/transfer_cmd.py,sha256=Qbgi7FvA8NoUAItv1NZxsLu_oFNgoWlxaALy1eFAs8M,11014
+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.0.dist-info/METADATA,sha256=vE1UQwE3DBr3gw8RLgkmFL3hbShOAlKbacEIx7fbM_8,349
+mm_sol-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_sol-0.6.0.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
+mm_sol-0.6.0.dist-info/RECORD,,

mm_sol/async_rpc.py

@@ -1,42 +0,0 @@
-from typing import Any
-
-from mm_std import Result, hra
-
-
-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 hra(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

@@ -1,158 +0,0 @@
-import httpx
-from mm_crypto_utils import Nodes, Proxies, random_node, random_proxy
-from mm_std import Err, Ok, Result
-from solana.exceptions import SolanaRpcException
-from solana.rpc.core import RPCException
-from solders.pubkey import Pubkey
-from solders.rpc.errors import InvalidParamsMessage
-from spl.token.instructions import get_associated_token_address
-
-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: 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: float = 10, proxies: Proxies = None
-) -> Result[int]:
-    res: Result[int] = Err("not started yet")
-    for _ in range(retries):
-        res = get_sol_balance(random_node(nodes), address, timeout=timeout, proxy=random_proxy(proxies))
-        if res.is_ok():
-            return res
-    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,
-    token_mint_address: str,
-    token_account: str | None = None,
-    timeout: float = 10,
-    proxy: str | None = None,
-) -> Result[int]:
-    try:
-        client = get_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 = 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:
-        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:
-        return Err(e.error_msg)
-    except Exception as e:
-        return Err(e)
-
-
-def get_token_balance_with_retries(
-    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 = get_token_balance(
-            random_node(nodes),
-            owner_address,
-            token_mint_address,
-            token_account,
-            timeout=timeout,
-            proxy=random_proxy(proxies),
-        )
-        if res.is_ok():
-            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/block.py

@@ -1,58 +0,0 @@
-from mm_std import Err, Ok, Result
-from pydantic import BaseModel
-
-from mm_sol.rpc import rpc_call
-
-
-class BlockTxCount(BaseModel):
-    slot: int
-    block_time: int | None
-    vote_tx_ok: int
-    vote_tx_error: int
-    non_vote_tx_ok: int
-    non_vote_tx_error: int
-
-
-def calc_block_tx_count(node: str, slot: int, timeout: int = 10, proxy: str | None = None) -> Result[BlockTxCount]:
-    res = rpc_call(node=node, method="getBlock", params=[slot], timeout=timeout, proxy=proxy)
-    if res.is_err():
-        return res
-    vote_tx_ok = 0
-    vote_tx_error = 0
-    non_vote_tx_ok = 0
-    non_vote_tx_error = 0
-    vote_tx_keys = [
-        "SysvarS1otHashes111111111111111111111111111",
-        "SysvarC1ock11111111111111111111111111111111",
-        "Vote111111111111111111111111111111111111111",
-    ]
-    try:
-        res_ok = res.unwrap()
-        txs = res_ok["transactions"]
-        block_time = res_ok["blockTime"]
-        for tx in txs:
-            is_error = tx["meta"]["err"] is not None
-            account_keys = tx["transaction"]["message"]["accountKeys"]
-            if len(account_keys) == 5 and vote_tx_keys == account_keys[2:]:
-                if is_error:
-                    vote_tx_error += 1
-                else:
-                    vote_tx_ok += 1
-            elif is_error:
-                non_vote_tx_error += 1
-            else:
-                non_vote_tx_ok += 1
-
-        return Ok(
-            BlockTxCount(
-                slot=slot,
-                vote_tx_ok=vote_tx_ok,
-                vote_tx_error=vote_tx_error,
-                non_vote_tx_ok=non_vote_tx_ok,
-                non_vote_tx_error=non_vote_tx_error,
-                block_time=block_time,
-            ),
-            res.data,
-        )
-    except Exception as e:
-        return Err(e, data=res.data)

mm_sol/rpc_async.py

@@ -1,65 +0,0 @@
-import json
-from collections.abc import Sequence
-from typing import Any
-
-import websockets
-from mm_std import DataResult, http_request
-
-
-async def rpc_call(
-    node: str,
-    method: str,
-    params: Sequence[object],
-    timeout: float,
-    proxy: str | None,
-    id_: int = 1,
-) -> DataResult[Any]:
-    data = {"jsonrpc": "2.0", "method": method, "params": params, "id": id_}
-    if node.startswith("http"):
-        return await _http_call(node, data, timeout, proxy)
-    return await _ws_call(node, data, timeout)
-
-
-async def _http_call(node: str, data: dict[str, object], timeout: float, proxy: str | None) -> DataResult[Any]:
-    res = await http_request(node, method="POST", proxy=proxy, timeout=timeout, json=data)
-    if res.is_error():
-        return res.to_data_result_err()
-    try:
-        parsed_body = res.parse_json_body()
-        err = parsed_body.get("error", {}).get("message", "")
-        if err:
-            return res.to_data_result_err(f"service_error: {err}")
-        if "result" in parsed_body:
-            return res.to_data_result_ok(parsed_body["result"])
-        return res.to_data_result_err("unknown_response")
-    except Exception as err:
-        return res.to_data_result_err(f"exception: {err}")
-
-
-async def _ws_call(node: str, data: dict[str, object], timeout: float) -> DataResult[Any]:
-    try:
-        async with websockets.connect(node, open_timeout=timeout) as ws:
-            await ws.send(json.dumps(data))
-            response = json.loads(await ws.recv())
-
-        err = response.get("error", {}).get("message", "")
-        if err:
-            return DataResult.err(f"service_error: {err}", {"res": response})
-        if "result" in response:
-            return DataResult.ok(response["result"], {"res": response})
-        return DataResult.err("unknown_response", {"res": response})
-    except TimeoutError:
-        return DataResult.err("timeout")
-    except Exception as err:
-        return DataResult.exception(err)
-
-
-async def get_block_height(node: str, timeout: float = 10, proxy: str | None = None) -> DataResult[int]:
-    return await rpc_call(node=node, method="getBlockHeight", params=[], timeout=timeout, proxy=proxy)
-
-
-async def get_balance(node: str, address: str, timeout: float = 10, proxy: str | None = None) -> DataResult[int]:
-    """Returns balance in lamports"""
-    return (await rpc_call(node=node, method="getBalance", params=[address], timeout=timeout, proxy=proxy)).map(
-        lambda r: r["value"]
-    )