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

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

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

{mm_sol-0.6.0 → mm_sol-0.6.1}/justfile

@@ -1,6 +1,6 @@
-set dotenv-load
-version := `uv run python -c 'import tomllib; print(tomllib.load(open("pyproject.toml", "rb"))["project"]["version"])'`
+set dotenv-load := true
 
+version := `uv run python -c 'import tomllib; print(tomllib.load(open("pyproject.toml", "rb"))["project"]["version"])'`
 
 clean:
     rm -rf .pytest_cache .mypy_cache .ruff_cache .coverage dist build src/*.egg-info
@@ -19,6 +19,9 @@ lint: format
     uv run ruff check src tests
     uv run mypy src
 
+lint-fix: format
+    uv run ruff check --fix src tests
+
 audit:
     uv run pip-audit
     uv run bandit -r -c "pyproject.toml" src
@@ -26,8 +29,8 @@ audit:
 publish: build
     git diff-index --quiet HEAD
     uvx twine upload dist/**
-    git tag -a 'v{{version}}' -m 'v{{version}}'
-    git push origin v{{version}}
+    git tag -a 'v{{ version }}' -m 'v{{ version }}'
+    git push origin v{{ version }}
 
 sync:
     uv sync

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

@@ -1,10 +1,10 @@
 [project]
 name = "mm-sol"
-version = "0.6.0"
+version = "0.6.1"
 description = ""
 requires-python = ">=3.12"
 dependencies = [
-    "mm-crypto-utils>=0.3.3",
+    "mm-crypto-utils>=0.3.4",
     "solana~=0.36.6",
     "solders~=0.26.0",
     "base58~=2.1.1",
@@ -12,7 +12,6 @@ dependencies = [
     "typer>=0.15.2",
     "jinja2>=3.1.6",
     "socksio>=1.0.0",
-    "mm-std>=0.4.5",
 ]
 [project.scripts]
 mm-sol = "mm_sol.cli.cli:app"
@@ -82,4 +81,5 @@ exclude_dirs = ["tests"]
 skips = ["B311"]
 
 [tool.pytest.ini_options]
+asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"

{mm_sol-0.6.0 → mm_sol-0.6.1}/src/mm_sol/cli/calcs.py

@@ -2,7 +2,7 @@ import mm_crypto_utils
 from mm_crypto_utils import Nodes, Proxies, VarInt
 from mm_std import Result
 
-from mm_sol import rpc, spl_token
+from mm_sol import retry
 from mm_sol.constants import SUFFIX_DECIMALS
 
 
@@ -20,15 +20,15 @@ async def calc_sol_value_for_address(
     value_expression = value_expression.lower()
     var = None
     if "balance" in value_expression:
-        res = await rpc.get_balance_with_retries(5, nodes, proxies, address=address)
-        if res.is_error():
+        res = await retry.get_sol_balance(5, nodes, proxies, address=address)
+        if res.is_err():
             return res
         var = VarInt("balance", res.unwrap())
 
     value = calc_sol_expression(value_expression, var)
     if "balance" in value_expression:
         value = value - fee
-    return Result.success(value)
+    return Result.ok(value)
 
 
 async def calc_token_value_for_address(
@@ -37,9 +37,9 @@ async def calc_token_value_for_address(
     var = None
     value_expression = value_expression.lower()
     if "balance" in value_expression:
-        res = await spl_token.get_balance_with_retries(5, nodes, proxies, owner=owner, token=token)
-        if res.is_error():
+        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)
-    return Result.success(value)
+    return Result.ok(value)

{mm_sol-0.6.0 → mm_sol-0.6.1}/src/mm_sol/cli/cmd/balance_cmd.py

@@ -4,7 +4,8 @@ import mm_crypto_utils
 from mm_std import print_json
 from pydantic import BaseModel, Field
 
-from mm_sol import rpc, spl_token
+import mm_sol.retry
+from mm_sol import retry
 from mm_sol.cli import cli_utils
 
 
@@ -45,7 +46,7 @@ async def run(
     proxies = await mm_crypto_utils.fetch_proxies_or_fatal(proxies_url) if proxies_url else None
 
     # sol balance
-    sol_balance_res = await rpc.get_balance_with_retries(3, rpc_url, proxies, address=wallet_address)
+    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:
@@ -53,16 +54,14 @@ async def run(
 
     # token balance
     if token_address:
-        token_balance_res = await spl_token.get_balance_with_retries(
-            3, rpc_url, proxies, owner=wallet_address, token=token_address
-        )
+        token_balance_res = await mm_sol.retry.get_token_balance(3, rpc_url, proxies, owner=wallet_address, token=token_address)
 
         if token_balance_res.is_ok():
             result.token_balance = token_balance_res.unwrap()
         else:
             result.errors.append("token_balance: " + token_balance_res.unwrap_error())
 
-        decimals_res = await spl_token.get_decimals_with_retries(3, rpc_url, proxies, token=token_address)
+        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:

{mm_sol-0.6.0 → mm_sol-0.6.1}/src/mm_sol/cli/cmd/balances_cmd.py

@@ -7,7 +7,8 @@ from mm_crypto_utils import ConfigValidators
 from mm_std import BaseConfig, fatal, print_json
 from pydantic import BeforeValidator, Field
 
-from mm_sol import converters, rpc, spl_token
+import mm_sol.retry
+from mm_sol import converters, retry
 from mm_sol.cli.validators import Validators
 
 
@@ -32,8 +33,8 @@ async def run(config_path: Path, print_config: bool) -> None:
 
     if config.tokens:
         for token_address in config.tokens:
-            res = await spl_token.get_decimals_with_retries(3, config.nodes, config.proxies, token=token_address)
-            if res.is_error():
+            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()}")
 
             token_decimals = res.unwrap()
@@ -50,9 +51,9 @@ async def _get_token_balances(
     result: dict[str, Decimal | None] = {}
     for account in accounts:
         result[account] = (
-            (await spl_token.get_balance_with_retries(3, config.nodes, config.proxies, owner=account, token=token_address))
+            (await mm_sol.retry.get_token_balance(3, config.nodes, config.proxies, owner=account, token=token_address))
             .map(lambda v: converters.to_token(v, token_decimals))
-            .ok
+            .value
         )
 
     return result
@@ -62,9 +63,9 @@ async def _get_sol_balances(accounts: list[str], config: Config) -> dict[str, De
     result = {}
     for account in accounts:
         result[account] = (
-            (await rpc.get_balance_with_retries(3, config.nodes, config.proxies, address=account))
+            (await retry.get_sol_balance(3, config.nodes, config.proxies, address=account))
             .map(lambda v: converters.lamports_to_sol(v))
-            .ok
+            .value
         )
 
     return result

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

@@ -13,12 +13,12 @@ from rich.live import Live
 from rich.table import Table
 from solders.signature import Signature
 
-from mm_sol import rpc, spl_token
+import mm_sol.retry
+from mm_sol import retry
 from mm_sol.cli import calcs, cli_utils
 from mm_sol.cli.cli_utils import BaseConfigParams
 from mm_sol.cli.validators import Validators
 from mm_sol.converters import lamports_to_sol, to_token
-from mm_sol.transfer import transfer_sol_with_retries, transfer_token_with_retries
 
 
 class Config(BaseConfig):
@@ -63,8 +63,8 @@ class Config(BaseConfig):
                 Validators.valid_sol_expression()(self.value_min_limit)
 
         if self.token:
-            res = await spl_token.get_decimals_with_retries(3, self.nodes, self.proxies, token=self.token)
-            if res.is_error():
+            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()}")
             self.token_decimals = res.unwrap()
 
@@ -131,10 +131,10 @@ async def _calc_value(transfer: Transfer, config: Config, transfer_sol_fee: int)
             fee=transfer_sol_fee,
         )
     logger.debug(f"{transfer.log_prefix}: value={value_res.ok_or_error()}")
-    if value_res.is_error():
+    if value_res.is_err():
         logger.info(f"{transfer.log_prefix}: calc value error, {value_res.unwrap_error()}")
 
-    return value_res.ok
+    return value_res.value
 
 
 def _check_value_min_limit(transfer: Transfer, value: int, config: Config) -> bool:
@@ -158,7 +158,7 @@ def _value_with_suffix(value: int, config: Config) -> str:
 async def _send_tx(transfer: Transfer, value: int, config: Config) -> Signature | None:
     logger.debug(f"{transfer.log_prefix}: value={_value_with_suffix(value, config)}")
     if config.token:
-        res = await transfer_token_with_retries(
+        res = await retry.transfer_token(
             3,
             config.nodes,
             config.proxies,
@@ -170,7 +170,7 @@ async def _send_tx(transfer: Transfer, value: int, config: Config) -> Signature
             decimals=config.token_decimals,
         )
     else:
-        res = await transfer_sol_with_retries(
+        res = await retry.transfer_sol(
             3,
             config.nodes,
             config.proxies,
@@ -180,10 +180,10 @@ async def _send_tx(transfer: Transfer, value: int, config: Config) -> Signature
             lamports=value,
         )
 
-    if res.is_error():
+    if res.is_err():
         logger.info(f"{transfer.log_prefix}: tx error {res.unwrap_error()}")
         return None
-    return res.ok
+    return res.value
 
 
 async def _transfer(transfer: Transfer, config: Config, cmd_params: TransferCmdParams) -> None:
@@ -255,12 +255,12 @@ async def _print_balances(config: Config) -> None:
 
 
 async def _get_sol_balance_str(address: str, config: Config) -> str:
-    res = await rpc.get_balance_with_retries(5, config.nodes, config.proxies, address=address)
+    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()
 
 
 async def _get_token_balance_str(address: str, config: Config) -> str:
     if not config.token:
         raise ValueError("token is not set")
-    res = await spl_token.get_balance_with_retries(5, config.nodes, config.proxies, owner=address, token=config.token)
+    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()

mm_sol-0.6.1/src/mm_sol/retry.py

@@ -0,0 +1,108 @@
+from mm_crypto_utils import Nodes, Proxies, retry_with_node_and_proxy
+from mm_std import Result
+from solders.solders import Pubkey, Signature
+
+from mm_sol import rpc, spl_token, transfer
+
+
+async def get_sol_balance(retries: int, nodes: Nodes, proxies: Proxies, *, address: str, timeout: float = 5) -> Result[int]:
+    return await retry_with_node_and_proxy(
+        retries,
+        nodes,
+        proxies,
+        lambda node, proxy: rpc.get_balance(node=node, address=address, timeout=timeout, proxy=proxy),
+    )
+
+
+async def get_token_balance(
+    retries: int,
+    nodes: Nodes,
+    proxies: Proxies,
+    *,
+    owner: str,
+    token: str,
+    token_account: str | None = None,
+    timeout: float = 5,
+) -> Result[int]:
+    return await retry_with_node_and_proxy(
+        retries,
+        nodes,
+        proxies,
+        lambda node, proxy: spl_token.get_balance(
+            node,
+            owner=owner,
+            token=token,
+            token_account=token_account,
+            timeout=timeout,
+            proxy=proxy,
+        ),
+    )
+
+
+async def transfer_token(
+    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.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_sol(
+    retries: int,
+    nodes: Nodes,
+    proxies: Proxies,
+    *,
+    from_address: str,
+    private_key: str,
+    to_address: str,
+    lamports: int,
+    timeout: float = 10,
+) -> Result[Signature]:
+    return await retry_with_node_and_proxy(
+        retries,
+        nodes,
+        proxies,
+        lambda node, proxy: transfer.transfer_sol(
+            node=node,
+            proxy=proxy,
+            from_address=from_address,
+            to_address=to_address,
+            lamports=lamports,
+            private_key=private_key,
+            timeout=timeout,
+        ),
+    )
+
+
+async def get_token_decimals(retries: int, nodes: Nodes, proxies: Proxies, *, token: str, timeout: float = 5) -> Result[int]:
+    return await retry_with_node_and_proxy(
+        retries,
+        nodes,
+        proxies,
+        lambda node, proxy: spl_token.get_decimals(node, token=token, proxy=proxy, timeout=timeout),
+    )

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

@@ -3,7 +3,6 @@ from collections.abc import Sequence
 from typing import Any
 
 import websockets
-from mm_crypto_utils import Nodes, Proxies, retry_with_node_and_proxy
 from mm_std import Result, http_request
 
 
@@ -23,18 +22,18 @@ 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_error():
-        return res.to_result_failure()
+    if res.is_err():
+        return res.to_err_result()
     try:
         parsed_body = res.parse_json_body()
         err = parsed_body.get("error", {}).get("message", "")
         if err:
-            return res.to_result_failure(f"service_error: {err}")
+            return res.to_err_result(f"service_error: {err}")
         if "result" in parsed_body:
-            return res.to_result_success(parsed_body["result"])
-        return res.to_result_failure("unknown_response")
+            return res.to_ok_result(parsed_body["result"])
+        return res.to_err_result("unknown_response")
     except Exception as e:
-        return res.to_result_failure(e)
+        return res.to_err_result(e)
 
 
 async def _ws_call(node: str, data: dict[str, object], timeout: float) -> Result[Any]:
@@ -46,14 +45,14 @@ async def _ws_call(node: str, data: dict[str, object], timeout: float) -> Result
 
         err = response.get("error", {}).get("message", "")
         if err:
-            return Result.failure(f"service_error: {err}", {"response": response})
+            return Result.err(f"service_error: {err}", {"response": response})
         if "result" in response:
-            return Result.success(response["result"], {"response": response})
-        return Result.failure("unknown_response", {"response": response})
+            return Result.ok(response["result"], {"response": response})
+        return Result.err("unknown_response", {"response": response})
     except TimeoutError:
-        return Result.failure("timeout", {"response": response})
+        return Result.err("timeout", {"response": response})
     except Exception as e:
-        return Result.failure(e, {"response": response})
+        return Result.err(e, {"response": response})
 
 
 async def get_block_height(node: str, timeout: float = 10, proxy: str | None = None) -> Result[int]:
@@ -65,17 +64,3 @@ async def get_balance(node: str, address: str, timeout: float = 5, proxy: str |
     return (await rpc_call(node=node, method="getBalance", params=[address], timeout=timeout, proxy=proxy)).map(
         lambda r: r["value"]
     )
-
-
-async def get_balance_with_retries(
-    retries: int, nodes: Nodes, proxies: Proxies, *, address: str, timeout: float = 5
-) -> Result[int]:
-    """
-    Retry get_balance with different nodes and proxies
-    """
-    return await retry_with_node_and_proxy(
-        retries,
-        nodes,
-        proxies,
-        lambda node, proxy: get_balance(node=node, address=address, timeout=timeout, proxy=proxy),
-    )

{mm_sol-0.6.0 → mm_sol-0.6.1}/src/mm_sol/rpc_sync.py

@@ -91,19 +91,19 @@ def rpc_call(
 def _http_call(node: str, data: dict[str, object], timeout: float, proxy: str | None) -> Result[Any]:
     res = http_request_sync(node, method="POST", proxy=proxy, timeout=timeout, json=data)
     try:
-        if res.is_error():
-            return res.to_result_failure()
+        if res.is_err():
+            return res.to_err_result()
 
         json_body = res.parse_json_body()
         err = pydash.get(json_body, "error.message")
         if err:
-            return res.to_result_failure(f"service_error: {err}")
+            return res.to_err_result(f"service_error: {err}")
         if "result" in json_body:
-            return res.to_result_success(json_body["result"])
+            return res.to_ok_result(json_body["result"])
 
-        return res.to_result_failure("unknown_response")
+        return res.to_err_result("unknown_response")
     except Exception as e:
-        return res.to_result_failure(e)
+        return res.to_err_result(e)
 
 
 def get_balance(node: str, address: str, timeout: float = 10, proxy: str | None = None) -> Result[int]:
@@ -137,7 +137,7 @@ def get_cluster_nodes(node: str, timeout: float = 30, proxy: str | None = None)
 
 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_error():
+    if res.is_err():
         return res
     try:
         data = res.unwrap()
@@ -174,9 +174,9 @@ def get_vote_accounts(node: str, timeout: float = 30, proxy: str | None = None)
                     last_vote=a["lastVote"],
                 ),
             )
-        return Result.success(result, res.extra)
+        return res.with_value(result)
     except Exception as e:
-        return Result.failure(e, res.extra)
+        return res.with_error(e)
 
 
 def get_leader_scheduler(
@@ -194,23 +194,6 @@ def get_leader_scheduler(
     )
 
 
-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_error():
-        return res
-    try:
-        res_ok = res.unwrap()
-        slot = res_ok["context"]["slot"]
-        first_slot = res_ok["value"]["range"]["firstSlot"]
-        last_slot = res_ok["value"]["range"]["lastSlot"]
-        leaders = []
-        for address, (leader, produced) in res.ok["value"]["byIdentity"].items():  # type: ignore[index]
-            leaders.append(BlockProduction.Leader(address=address, produced=produced, skipped=leader - produced))
-        return Result.success(BlockProduction(slot=slot, first_slot=first_slot, last_slot=last_slot, leaders=leaders), res.extra)
-    except Exception as e:
-        return Result.failure(e, res.extra)
-
-
 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]).map(
         lambda ok: StakeActivation(**ok),

mm_sol-0.6.1/src/mm_sol/spl_token.py

@@ -0,0 +1,48 @@
+from mm_std import Result
+from solana.exceptions import SolanaRpcException
+from solana.rpc.core import RPCException
+from solders.solders import InvalidParamsMessage, Pubkey, get_associated_token_address
+
+from mm_sol.utils import get_async_client
+
+
+async def get_balance(
+    node: str,
+    owner: str,
+    token: str,
+    token_account: str | None = None,
+    timeout: float = 5,
+    proxy: str | None = None,
+) -> Result[int]:
+    response = None
+    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), Pubkey.from_string(token)))
+
+        res = await client.get_token_account_balance(Pubkey.from_string(token_account))
+        response = res.to_json()
+
+        # Sometimes it not raise an error, but it returns this :(
+        if isinstance(res, InvalidParamsMessage) and "could not find account" in res.message:
+            return Result.ok(0, {"response": response})
+        return Result.ok(int(res.value.amount), {"response": response})
+    except RPCException as e:
+        if "could not find account" in str(e):
+            return Result.ok(0, {"response": response, "rpc_exception": str(e)})
+        return Result.err(e, {"response": response})
+    except SolanaRpcException as e:
+        return Result.err((e.error_msg, e), {"response": response})
+    except Exception as e:
+        return Result.err(e, {"response": response})
+
+
+async def get_decimals(node: str, token: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
+    response = None
+    try:
+        client = get_async_client(node, proxy=proxy, timeout=timeout)
+        res = await client.get_token_supply(Pubkey.from_string(token))
+        response = res.to_json()
+        return Result.ok(res.value.decimals, {"response": response})
+    except Exception as e:
+        return Result.err(e, {"response": response})

{mm_sol-0.6.0 → mm_sol-0.6.1}/src/mm_sol/transfer.py

@@ -1,5 +1,4 @@
 import pydash
-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
@@ -15,39 +14,6 @@ from mm_sol import rpc_sync, utils
 from mm_sol.account import check_private_key, get_keypair
 
 
-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,
@@ -64,7 +30,7 @@ async def transfer_token(
     # TODO: try/except this function!!!
     acc = get_keypair(private_key)
     if not check_private_key(from_address, private_key):
-        return Result.failure("invalid_private_key")
+        return Result.err("invalid_private_key")
 
     from_address = utils.pubkey(from_address)
     token_mint_address = utils.pubkey(token_mint_address)
@@ -83,7 +49,7 @@ async def transfer_token(
             create_account_res = token_client.create_associated_token_account(to_address, skip_confirmation=False)
             logs.append(create_account_res)
         else:
-            return Result.failure("no_token_account")
+            return Result.err("no_token_account")
 
     res = await token_client.transfer_checked(
         source=from_token_account,
@@ -95,34 +61,7 @@ async def transfer_token(
     )
     logs.append(res)
 
-    return Result.success(res.value, {"logs": logs})
-
-
-async def transfer_sol_with_retries(
-    retries: int,
-    nodes: Nodes,
-    proxies: Proxies,
-    *,
-    from_address: str,
-    private_key: str,
-    to_address: str,
-    lamports: int,
-    timeout: float = 10,
-) -> Result[Signature]:
-    return await retry_with_node_and_proxy(
-        retries,
-        nodes,
-        proxies,
-        lambda node, proxy: transfer_sol(
-            node=node,
-            proxy=proxy,
-            from_address=from_address,
-            to_address=to_address,
-            lamports=lamports,
-            private_key=private_key,
-            timeout=timeout,
-        ),
-    )
+    return Result.ok(res.value, {"logs": logs})
 
 
 async def transfer_sol(
@@ -137,7 +76,7 @@ async def transfer_sol(
 ) -> Result[Signature]:
     acc = get_keypair(private_key)
     if not check_private_key(from_address, private_key):
-        return Result.failure("invalid_private_key")
+        return Result.err("invalid_private_key")
 
     client = utils.get_async_client(node, proxy=proxy, timeout=timeout)
     data = None
@@ -148,9 +87,9 @@ async def transfer_sol(
         tx = Transaction([acc], msg, blockhash.value.blockhash)
         res = await client.send_transaction(tx)
         data = res.to_json()
-        return Result.success(res.value, {"response": data})
+        return Result.ok(res.value, {"response": data})
     except Exception as e:
-        return Result.failure(e, {"response": data})
+        return Result.err(e, {"response": data})
 
 
 class SolTransferInfo(BaseModel):
@@ -161,7 +100,7 @@ class SolTransferInfo(BaseModel):
 
 def find_sol_transfers(node: str, tx_signature: str) -> Result[list[SolTransferInfo]]:
     res = rpc_sync.get_transaction(node, tx_signature, encoding="jsonParsed")
-    if res.is_error():
+    if res.is_err():
         return res  # type: ignore[return-value]
     result = []
     try:
@@ -174,6 +113,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 Result.success(result, res.extra)
+        return res.with_value(result)
     except Exception as e:
-        return Result.failure(e, res.extra)
+        return Result.err(e, res.extra)

{mm_sol-0.6.0 → mm_sol-0.6.1}/tests/test_rpc_sync.py

@@ -44,11 +44,6 @@ def test_get_leader_scheduler(testnet_node, random_proxy):
     assert len(res.unwrap()) > 10
 
 
-def test_get_block_production(testnet_node, random_proxy):
-    res = rpc_sync.get_block_production(testnet_node, proxy=random_proxy)
-    assert res.unwrap().slot > 1000
-
-
 def test_get_transaction(mainnet_node, random_proxy):
     tx_hash = "2vifJ5g4inS4spZLQMUyVstvMrCM2mg1QC9xjD6bgsiMUwp8sTE5waCdshJ8SVaH95WGtexjH3q8ot1GoKe9yK3h"
     res = rpc_sync.get_transaction(mainnet_node, tx_hash, 0, proxy=random_proxy)

{mm_sol-0.6.0 → mm_sol-0.6.1}/tests/test_spl_token.py

@@ -14,7 +14,7 @@ async def test_get_balance(mainnet_node, usdt_token_address, usdt_owner_address,
 async def test_get_balance_no_token_account(mainnet_node, usdt_token_address, random_proxy):
     res = await spl_token.get_balance(mainnet_node, generate_account().public_key, usdt_token_address, proxy=random_proxy)
 
-    assert res.ok == 0
+    assert res.unwrap() == 0
 
 
 async def test_get_decimals(mainnet_node, usdt_token_address, random_proxy):

{mm_sol-0.6.0 → mm_sol-0.6.1}/uv.lock

@@ -562,25 +562,24 @@ wheels = [
 
 [[package]]
 name = "mm-crypto-utils"
-version = "0.3.3"
+version = "0.3.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "loguru" },
     { name = "mm-std" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2b/3b/584e21e4a471f6cbc7237e924c550ab4a19be8e0d2064e76a4a5f2f4fe1a/mm_crypto_utils-0.3.3-py3-none-any.whl", hash = "sha256:4d53940267a84f4a4dd00b832cedb76264d1d6fcacccdd0acc3c2ec2f79eacc7", size = 10092 },
+    { url = "https://files.pythonhosted.org/packages/e8/53/d89b21605698bfe087b8768d808c61ebac9d299694bf4a11bd84460691b3/mm_crypto_utils-0.3.4-py3-none-any.whl", hash = "sha256:964f81c53406ca58b0627dfd13c5743f1d919a94580b1683025bd40518983dd9", size = 10075 },
 ]
 
 [[package]]
 name = "mm-sol"
-version = "0.6.0"
+version = "0.6.1"
 source = { editable = "." }
 dependencies = [
     { name = "base58" },
     { name = "jinja2" },
     { name = "mm-crypto-utils" },
-    { name = "mm-std" },
     { name = "mnemonic" },
     { name = "socksio" },
     { name = "solana" },
@@ -603,8 +602,7 @@ dev = [
 requires-dist = [
     { name = "base58", specifier = "~=2.1.1" },
     { name = "jinja2", specifier = ">=3.1.6" },
-    { name = "mm-crypto-utils", specifier = ">=0.3.3" },
-    { name = "mm-std", specifier = ">=0.4.5" },
+    { name = "mm-crypto-utils", specifier = ">=0.3.4" },
     { name = "mnemonic", specifier = "==0.21" },
     { name = "socksio", specifier = ">=1.0.0" },
     { name = "solana", specifier = "~=0.36.6" },
@@ -625,7 +623,7 @@ dev = [
 
 [[package]]
 name = "mm-std"
-version = "0.4.5"
+version = "0.4.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -641,7 +639,7 @@ dependencies = [
     { name = "tomlkit" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ee/c3/22c61044cc48eaacc9b8dcf61d72de5085539d354ab10996c16de2979aed/mm_std-0.4.5-py3-none-any.whl", hash = "sha256:02b7269ad2c74c8551a906246b66fdd91ea5fb83f6108d5690da64780e31354e", size = 23604 },
+    { url = "https://files.pythonhosted.org/packages/df/7c/bf7484f886905fd0c045b3ef617eac97cf4128e85191cc232df41c44b218/mm_std-0.4.6-py3-none-any.whl", hash = "sha256:f9f74ed75bda4569d8ed3fbb61b7f0add9668e800e93724cf84b61b599b77a68", size = 23821 },
 ]
 
 [[package]]
@@ -1016,15 +1014,16 @@ wheels = [
 
 [[package]]
 name = "pydantic-settings"
-version = "2.8.1"
+version = "2.9.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pydantic" },
     { name = "python-dotenv" },
+    { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/88/82/c79424d7d8c29b994fb01d277da57b0a9b09cc03c3ff875f9bd8a86b2145/pydantic_settings-2.8.1.tar.gz", hash = "sha256:d5c663dfbe9db9d5e1c646b2e161da12f0d734d422ee56f567d0ea2cee4e8585", size = 83550 }
+sdist = { url = "https://files.pythonhosted.org/packages/67/1d/42628a2c33e93f8e9acbde0d5d735fa0850f3e6a2f8cb1eb6c40b9a732ac/pydantic_settings-2.9.1.tar.gz", hash = "sha256:c509bf79d27563add44e8446233359004ed85066cd096d8b510f715e6ef5d268", size = 163234 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0b/53/a64f03044927dc47aafe029c42a5b7aabc38dfb813475e0e1bf71c4a59d0/pydantic_settings-2.8.1-py3-none-any.whl", hash = "sha256:81942d5ac3d905f7f3ee1a70df5dfb62d5569c12f51a5a647defc1c3d9ee2e9c", size = 30839 },
+    { url = "https://files.pythonhosted.org/packages/b6/5f/d6d641b490fd3ec2c4c13b4244d68deea3a1b970a97be64f34fb5504ff72/pydantic_settings-2.9.1-py3-none-any.whl", hash = "sha256:59b4f431b1defb26fe620c71a7d3968a710d719f5f4cdbbdb7926edeb770f6ef", size = 44356 },
 ]
 
 [[package]]

mm_sol-0.6.0/src/mm_sol/spl_token.py

@@ -1,85 +0,0 @@
-from mm_crypto_utils import Nodes, Proxies, retry_with_node_and_proxy
-from mm_std import Result
-from solana.exceptions import SolanaRpcException
-from solana.rpc.core import RPCException
-from solders.solders import InvalidParamsMessage, Pubkey, get_associated_token_address
-
-from mm_sol.utils import get_async_client
-
-
-async def get_balance(
-    node: str,
-    owner: str,
-    token: str,
-    token_account: str | None = None,
-    timeout: float = 5,
-    proxy: str | None = None,
-) -> Result[int]:
-    response = None
-    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), Pubkey.from_string(token)))
-
-        res = await client.get_token_account_balance(Pubkey.from_string(token_account))
-        response = res.to_json()
-
-        # Sometimes it not raise an error, but it returns this :(
-        if isinstance(res, InvalidParamsMessage) and "could not find account" in res.message:
-            return Result.success(0, {"response": response})
-        return Result.success(int(res.value.amount), {"response": response})
-    except RPCException as e:
-        if "could not find account" in str(e):
-            return Result.success(0, {"response": response, "rpc_exception": str(e)})
-        return Result.failure(e, {"response": response})
-    except SolanaRpcException as e:
-        return Result.failure((e.error_msg, e), {"response": response})
-    except Exception as e:
-        return Result.failure(e, {"response": response})
-
-
-async def get_balance_with_retries(
-    retries: int,
-    nodes: Nodes,
-    proxies: Proxies,
-    *,
-    owner: str,
-    token: str,
-    token_account: str | None = None,
-    timeout: float = 5,
-) -> Result[int]:
-    return await retry_with_node_and_proxy(
-        retries,
-        nodes,
-        proxies,
-        lambda node, proxy: get_balance(
-            node,
-            owner=owner,
-            token=token,
-            token_account=token_account,
-            timeout=timeout,
-            proxy=proxy,
-        ),
-    )
-
-
-async def get_decimals(node: str, token: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
-    response = None
-    try:
-        client = get_async_client(node, proxy=proxy, timeout=timeout)
-        res = await client.get_token_supply(Pubkey.from_string(token))
-        response = res.to_json()
-        return Result.success(res.value.decimals, {"response": response})
-    except Exception as e:
-        return Result.failure(e, {"response": response})
-
-
-async def get_decimals_with_retries(
-    retries: int, nodes: Nodes, proxies: Proxies, *, token: str, timeout: float = 5
-) -> Result[int]:
-    return await retry_with_node_and_proxy(
-        retries,
-        nodes,
-        proxies,
-        lambda node, proxy: get_decimals(node, token=token, proxy=proxy, timeout=timeout),
-    )