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

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/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/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/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/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()
 
@@ -130,11 +130,11 @@ 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()}")
-    if value_res.is_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()}")
 
-    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)
-    return res.map(lambda ok: str(lamports_to_sol(ok, config.round_ndigits))).ok_or_error()
+    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))).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 spl_token.get_balance_with_retries(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()
+    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))).value_or_error()

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/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()
     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(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(parsed_body["result"])
+        return res.to_err("unknown_response")
     except Exception as e:
-        return res.to_result_failure(e)
+        return res.to_err(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/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()
 
         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(f"service_error: {err}")
         if "result" in json_body:
-            return res.to_result_success(json_body["result"])
+            return res.to_ok(json_body["result"])
 
-        return res.to_result_failure("unknown_response")
+        return res.to_err("unknown_response")
     except Exception as e:
-        return res.to_result_failure(e)
+        return res.to_err(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/spl_token.py

@@ -1,4 +1,3 @@
-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
@@ -26,41 +25,16 @@ async def get_balance(
 
         # 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})
+            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.success(0, {"response": response, "rpc_exception": str(e)})
-        return Result.failure(e, {"response": response})
+            return Result.ok(0, {"response": response, "rpc_exception": str(e)})
+        return Result.err(e, {"response": response})
     except SolanaRpcException as e:
-        return Result.failure((e.error_msg, e), {"response": response})
+        return Result.err((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,
-        ),
-    )
+        return Result.err(e, {"response": response})
 
 
 async def get_decimals(node: str, token: str, timeout: float = 5, proxy: str | None = None) -> Result[int]:
@@ -69,17 +43,6 @@ async def get_decimals(node: str, token: str, timeout: float = 5, proxy: str | N
         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})
+        return Result.ok(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),
-    )
+        return Result.err(e, {"response": response})

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.dist-info → mm_sol-0.6.2.dist-info}/METADATA

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: mm-sol
-Version: 0.6.0
+Version: 0.6.2
 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.6
 Requires-Dist: mnemonic==0.21
 Requires-Dist: socksio>=1.0.0
 Requires-Dist: solana~=0.36.6

{mm_sol-0.6.0.dist-info → mm_sol-0.6.2.dist-info}/RECORD

@@ -3,28 +3,29 @@ 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/retry.py,sha256=9ejCcrHbJFOcZVKdbUASynLs1YHw04VAIKGH8mIJ1OI,2894
+mm_sol/rpc.py,sha256=LhXrHIz58iOG2ES8m67ycBCwkJx-4pLBuDt6Hsq6OkM,2422
+mm_sol/rpc_sync.py,sha256=A06MTSFQ7UUJgm0fy4a6ipqqY2vdDwS07UGXkdrvqWw,7148
+mm_sol/spl_token.py,sha256=hEWVch17EdudlL_tj3ZInCa9wB0iK8hwwpFucmVi7Pc,1941
+mm_sol/transfer.py,sha256=6CXzeMe91JtG8SuTadYQ-DLHJFyskytmBItGVEPh7Os,4410
 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/calcs.py,sha256=TR-mWQWYyHPdJYi_rvqiebqBqRsXsaqaSdvwCoSax1g,1675
 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/balance_cmd.py,sha256=ot6X7gTSoMcjapVkAgDlA9Wyo4YeFBIRA7GLjTXsu98,2469
+mm_sol/cli/cmd/balances_cmd.py,sha256=XNNyU02mvSxPdfD3usxucNiiHagxSnLe1rKihj-ya78,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/node_cmd.py,sha256=o3YktYk4o_ya8srN_It2BITam4HlpFMK11ajYNTGuKA,350
+mm_sol/cli/cmd/transfer_cmd.py,sha256=8QMfqUcvS63V_AeEvlvsuIEZIv_ydrMtuCOr4LvcyoY,10922
 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-0.6.2.dist-info/METADATA,sha256=H01qTQ1WZUC-TNzgDPimXXZpIFZVVcf6CvuvmeE6UsQ,320
+mm_sol-0.6.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_sol-0.6.2.dist-info/entry_points.txt,sha256=MrYnosumy9nsITSAw5TiR3WXDwsdoF0YvUIlZ38TLLs,46
+mm_sol-0.6.2.dist-info/RECORD,,