mm-sol 0.2.5__py3-none-any.whl

mm_sol/account.py

@@ -0,0 +1,90 @@
+import random
+
+import base58
+import pydash
+from mm_std import Err, Ok, Result
+from pydantic import BaseModel
+from solana.rpc.api import Client
+from solders.keypair import Keypair
+from solders.pubkey import Pubkey
+from solders.rpc.responses import GetAccountInfoResp
+
+
+class NewAccount(BaseModel):
+    public_key: str
+    private_key_base58: str
+    private_key_arr: list[int]
+
+
+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())
+    return NewAccount(public_key=public_key, private_key_base58=private_key_base58, private_key_arr=private_key_arr)
+
+
+def get_keypair(private_key: str | list[int]) -> Keypair:
+    if isinstance(private_key, str):
+        if "[" in private_key:
+            private_key_ = [int(x) for x in private_key.replace("[", "").replace("]", "").split(",")]
+        else:
+            private_key_ = base58.b58decode(private_key)  # type: ignore[assignment]
+    else:
+        private_key_ = private_key
+    return Keypair.from_bytes(private_key_)
+
+
+def check_private_key(public_key_base58: str, private_key: str | list[int]) -> bool:
+    return str(get_keypair(private_key).pubkey()) == public_key_base58
+
+
+def get_public_key(private_key: str) -> str:
+    if "[" in private_key:
+        private_key_ = [int(x) for x in private_key.replace("[", "").replace("]", "").split(",")]
+    else:
+        private_key_ = base58.b58decode(private_key)  # type: ignore[assignment]
+    return str(Keypair.from_bytes(private_key_).pubkey())
+
+
+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")
+
+
+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
+
+
+def get_private_key_arr_str(private_key: str) -> str:
+    return f"[{','.join(str(x) for x in get_private_key_arr(private_key))}]"
+
+
+def is_empty_account(*, address: str, node: str | None = None, nodes: list[str] | None = None, attempts: int = 3) -> Result[bool]:
+    if not node and not nodes:
+        raise ValueError("node or nodes must be set")
+    error = None
+    data = None
+    for _ in range(attempts):
+        try:
+            client = Client(node or random.choice(nodes))  # type: ignore[arg-type]
+            res: GetAccountInfoResp = client.get_account_info(Pubkey.from_string(address))
+            data = res
+            slot = pydash.get(res, "result.context.slot")
+            value = pydash.get(res, "result.value")
+            if slot and value is None:
+                return Ok(True, data=data)
+            if slot and value:
+                return Ok(False, data=data)
+        except Exception as e:
+            error = str(e)
+    return Err(error or "unknown response", data=data)
+
+
+def is_valid_pubkey(pubkey: str) -> bool:
+    try:
+        Pubkey.from_string(pubkey)
+        return True  # noqa: TRY300
+    except Exception:
+        return False

mm_sol/balance.py

@@ -0,0 +1,18 @@
+from mm_std import Err, Result
+
+from mm_sol import rpc
+from mm_sol.types import Nodes, Proxies
+from mm_sol.utils import get_node, get_proxy
+
+
+def get_balance(node: str, address: str, timeout: int = 10, proxy: str | None = None) -> Result[int]:
+    return rpc.get_balance(node, address, timeout, proxy)
+
+
+def get_balance_with_retries(nodes: Nodes, address: str, retries: int, timeout: int = 10, proxies: Proxies = None) -> Result[int]:
+    res: Result[int] = Err("not started yet")
+    for _ in range(retries):
+        res = get_balance(get_node(nodes), address, timeout=timeout, proxy=get_proxy(proxies))
+        if res.is_ok():
+            return res
+    return res

mm_sol/block.py

@@ -0,0 +1,58 @@
+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/cli/cli.py

@@ -0,0 +1,87 @@
+from enum import Enum
+from typing import Annotated
+
+import typer
+from mm_std import print_plain
+
+from .cmd import balance_cmd, balances_cmd, example_cmd, node_cmd, transfer_sol_cmd
+from .cmd.wallet import keypair_cmd, new_cmd
+
+app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
+
+wallet_app = typer.Typer(no_args_is_help=True, help="Wallet commands: generate new accounts, private to address")
+app.add_typer(wallet_app, name="wallet")
+app.add_typer(wallet_app, name="w", hidden=True)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        import importlib.metadata
+
+        print_plain(f"mm-sol: {importlib.metadata.version('mm-sol')}")
+        raise typer.Exit
+
+
+@app.callback()
+def main(_version: bool = typer.Option(None, "--version", callback=version_callback, is_eager=True)) -> None:
+    pass
+
+
+class ConfigExample(str, Enum):
+    balances = "balances"
+    transfer_sol = "transfer-sol"
+
+
+@app.command(name="example", help="Print an example of config for a command")
+def example_command(command: Annotated[ConfigExample, typer.Argument()]) -> None:
+    example_cmd.run(command.value)
+
+
+@app.command(name="balance", help="Gen account balance")
+def balance_command(
+    wallet_address: Annotated[str, typer.Argument()],
+    token_address: Annotated[str | None, typer.Option("--token", "-t")] = None,
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="MM_SOL_RPC_URL")] = "",  # nosec
+    proxies_url: Annotated[str, typer.Option("--proxies-url", envvar="MM_SOL_PROXIES_URL")] = "",  # nosec
+    lamport: bool = typer.Option(False, "--lamport", "-l", help="Print balances in lamports"),
+) -> None:
+    balance_cmd.run(rpc_url, wallet_address, token_address, lamport, proxies_url)
+
+
+@app.command(name="balances", help="Print SOL and token balances for accounts")
+def balances_command(
+    config_path: str, print_config: Annotated[bool, typer.Option("--config", "-c", help="Print config and exit")] = False
+) -> None:
+    balances_cmd.run(config_path, print_config)
+
+
+@app.command(name="transfer-sol", help="Transfer SOL")
+def transfer_sol_command(
+    config_path: str, print_config: Annotated[bool, typer.Option("--config", "-c", help="Print config and exit")] = False
+) -> None:
+    transfer_sol_cmd.run(config_path, print_config)
+
+
+@app.command(name="node", help="Check RPC urls")
+def node_command(
+    urls: Annotated[list[str], typer.Argument()],
+    proxy: Annotated[str | None, typer.Option("--proxy", "-p", help="Proxy")] = None,
+) -> None:
+    node_cmd.run(urls, proxy)
+
+
+@wallet_app.command(name="new", help="Generate new accounts")
+def generate_accounts_command(
+    limit: Annotated[int, typer.Option("--limit", "-l")] = 5,
+    array: Annotated[bool, typer.Option("--array", help="Print private key in the array format.")] = False,
+) -> None:
+    new_cmd.run(limit, array)
+
+
+@wallet_app.command(name="keypair", help="Print public, private_base58, private_arr by a private key")
+def keypair_command(private_key: str) -> None:
+    keypair_cmd.run(private_key)
+
+
+if __name__ == "__main_":
+    app()

mm_sol/cli/cli_utils.py

@@ -0,0 +1,36 @@
+import sys
+
+import pydash
+from mm_std import BaseConfig, fatal, hr, print_json
+
+
+def print_config_and_exit(exit_: bool, config: BaseConfig, exclude: set[str] | None = None) -> None:
+    if exit_:
+        print_json(config.model_dump(exclude=exclude))
+        sys.exit(0)
+
+
+def public_rpc_url(url: str | None) -> str:
+    if not url:
+        return "https://api.mainnet-beta.solana.com"
+
+    match url.lower():
+        case "mainnet":
+            return "https://api.mainnet-beta.solana.com"
+        case "testnet":
+            return "https://api.testnet.solana.com"
+        case "devnet":
+            return "https://api.devnet.solana.com"
+
+    return url
+
+
+def load_proxies_from_url(proxies_url: str) -> list[str]:
+    try:
+        res = hr(proxies_url)
+        if res.is_error():
+            fatal(f"Can't get proxies: {res.error}")
+        proxies = [p.strip() for p in res.body.splitlines() if p.strip()]
+        return pydash.uniq(proxies)
+    except Exception as err:
+        fatal(f"Can't get  proxies from the url: {err}")

mm_sol/cli/cmd/balance_cmd.py

@@ -0,0 +1,75 @@
+from decimal import Decimal
+
+from mm_std import Ok, print_json
+from pydantic import BaseModel, Field
+
+from mm_sol import balance, token
+from mm_sol.cli import cli_utils
+
+
+class HumanReadableBalanceResult(BaseModel):
+    sol_balance: Decimal | None
+    token_balance: Decimal | None
+    token_decimals: int | None
+    errors: list[str]
+
+
+class BalanceResult(BaseModel):
+    sol_balance: int | None = None
+    token_balance: int | None = None
+    token_decimals: int | None = None
+    errors: list[str] = Field(default_factory=list)
+
+    def to_human_readable(self) -> HumanReadableBalanceResult:
+        sol_balance = Decimal(self.sol_balance) / 10**9 if self.sol_balance is not None else None
+        token_balance = None
+        if self.token_balance is not None and self.token_decimals is not None:
+            token_balance = Decimal(self.token_balance) / 10**self.token_decimals
+        return HumanReadableBalanceResult(
+            sol_balance=sol_balance, token_balance=token_balance, token_decimals=self.token_decimals, errors=self.errors
+        )
+
+
+def run(
+    rpc_url: str,
+    wallet_address: str,
+    token_address: str | None,
+    lamport: bool,
+    proxies_url: str | None,
+) -> None:
+    result = BalanceResult()
+
+    rpc_url = cli_utils.public_rpc_url(rpc_url)
+    proxies = cli_utils.load_proxies_from_url(proxies_url) if proxies_url else None
+
+    # sol balance
+    sol_balance_res = balance.get_balance_with_retries(rpc_url, wallet_address, retries=3, proxies=proxies)
+    if isinstance(sol_balance_res, Ok):
+        result.sol_balance = sol_balance_res.ok
+    else:
+        result.errors.append("sol_balance: " + sol_balance_res.err)
+
+    # token balance
+    if token_address:
+        token_balance_res = token.get_balance_with_retries(
+            nodes=rpc_url,
+            owner_address=wallet_address,
+            token_mint_address=token_address,
+            retries=3,
+            proxies=proxies,
+        )
+        if isinstance(token_balance_res, Ok):
+            result.token_balance = token_balance_res.ok
+        else:
+            result.errors.append("token_balance: " + token_balance_res.err)
+
+        decimals_res = token.get_decimals_with_retries(rpc_url, token_address, retries=3, proxies=proxies)
+        if isinstance(decimals_res, Ok):
+            result.token_decimals = decimals_res.ok
+        else:
+            result.errors.append("token_decimals: " + decimals_res.err)
+
+    if lamport:
+        print_json(result)
+    else:
+        print_json(result.to_human_readable())

mm_sol/cli/cmd/balances_cmd.py

@@ -0,0 +1,62 @@
+import random
+from decimal import Decimal
+from typing import Any
+
+from mm_std import BaseConfig, print_console, str_to_list
+from pydantic import StrictStr, field_validator
+
+from mm_sol import balance, utils
+from mm_sol.cli import cli_utils
+from mm_sol.token import get_balance_with_retries
+
+
+class Config(BaseConfig):
+    accounts: list[StrictStr]
+    nodes: list[StrictStr]
+    tokens: list[StrictStr] | None = None
+
+    @field_validator("accounts", "nodes", "tokens", mode="before")
+    def to_list_validator(cls, v: list[str] | str | None) -> list[str]:
+        return str_to_list(v)
+
+    @property
+    def random_node(self) -> str:
+        return random.choice(self.nodes)
+
+
+def run(config_path: str, print_config: bool) -> None:
+    config = Config.read_config_or_exit(config_path)
+    cli_utils.print_config_and_exit(print_config, config)
+
+    # config = parse_config(ctx, config_path, Config)
+    # print_config_and_exit(ctx, config)
+    result: dict[str, Any] = {"sol": _get_sol_balances(config.accounts, config.nodes)}
+    result["sol_sum"] = sum([v for v in result["sol"].values() if v is not None])
+
+    if config.tokens:
+        for token in config.tokens:
+            result[token] = _get_token_balances(token, config.accounts, config.nodes)
+            result[token + "_sum"] = sum([v for v in result[token].values() if v is not None])
+
+    print_console(result, print_json=True)
+
+
+def _get_token_balances(token: str, accounts: list[str], nodes: list[str]) -> dict[str, int | None]:
+    result = {}
+    for account in accounts:
+        # result[account] = _get_token_balance(token, account, nodes)
+        result[account] = get_balance_with_retries(
+            nodes=nodes,
+            owner_address=account,
+            token_mint_address=token,
+            retries=3,
+        ).ok_or_none()
+    return result
+
+
+def _get_sol_balances(accounts: list[str], nodes: list[str]) -> dict[str, Decimal | None]:
+    result = {}
+    for account in accounts:
+        res = balance.get_balance_with_retries(nodes=nodes, address=account, retries=3)
+        result[account] = utils.lamports_to_sol(res.unwrap(), ndigits=2) if res.is_ok() else None
+    return result

mm_sol/cli/cmd/example_cmd.py

@@ -0,0 +1,8 @@
+from pathlib import Path
+
+from mm_std import print_plain
+
+
+def run(module: str) -> None:
+    example_file = Path(Path(__file__).parent.absolute(), "../examples", f"{module}.yml")
+    print_plain(example_file.read_text())

mm_sol/cli/cmd/node_cmd.py

@@ -0,0 +1,9 @@
+from mm_std import print_console
+
+from mm_sol import rpc
+
+
+def run(urls: list[str], proxy: str | None) -> None:
+    for url in urls:
+        res = rpc.get_block_height(url, proxy=proxy, timeout=10)
+        print_console(url, res.ok_or_err())

mm_sol/cli/cmd/transfer_sol_cmd.py

@@ -0,0 +1,41 @@
+import random
+from decimal import Decimal
+
+from mm_std import BaseConfig, print_console, str_to_list
+from pydantic import StrictStr, field_validator
+
+from mm_sol.cli import cli_utils
+from mm_sol.transfer import transfer_sol
+
+
+class Config(BaseConfig):
+    from_address: StrictStr
+    private_key: StrictStr
+    recipients: list[StrictStr]
+    nodes: list[StrictStr]
+    amount: Decimal
+
+    @field_validator("recipients", "nodes", mode="before")
+    def to_list_validator(cls, v: list[str] | str | None) -> list[str]:
+        return str_to_list(v)
+
+    @property
+    def random_node(self) -> str:
+        return random.choice(self.nodes)
+
+
+def run(config_path: str, print_config: bool) -> None:
+    config = Config.read_config_or_exit(config_path)
+    cli_utils.print_config_and_exit(print_config, config)
+
+    result = {}
+    for recipient in config.recipients:
+        res = transfer_sol(
+            from_address=config.from_address,
+            private_key_base58=config.private_key,
+            recipient_address=recipient,
+            amount_sol=config.amount,
+            nodes=config.nodes,
+        )
+        result[recipient] = res.ok_or_err()
+    print_console(result, print_json=True)

mm_sol/cli/cmd/wallet/keypair_cmd.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+
+from mm_std import print_console
+
+from mm_sol.account import (
+    get_private_key_arr_str,
+    get_private_key_base58,
+    get_public_key,
+)
+
+
+def run(private_key: str) -> None:
+    if (file := Path(private_key)).is_file():
+        private_key = file.read_text()
+
+    public = get_public_key(private_key)
+    private_base58 = get_private_key_base58(private_key)
+    private_arr = get_private_key_arr_str(private_key)
+    print_console({"public": public, "private_base58": private_base58, "private_arr": private_arr}, print_json=True)

mm_sol/cli/cmd/wallet/new_cmd.py

@@ -0,0 +1,14 @@
+from mm_std import print_console
+
+from mm_sol.account import generate_account, get_private_key_arr_str
+
+
+def run(limit: int, array: bool) -> None:
+    result = {}
+    for _ in range(limit):
+        acc = generate_account()
+        private_key = acc.private_key_base58
+        if array:
+            private_key = get_private_key_arr_str(acc.private_key_base58)
+        result[acc.public_key] = private_key
+    print_console(result, print_json=True)

mm_sol/cli/examples/balances.yml

@@ -0,0 +1,11 @@
+accounts: |
+  5BJ9ViMj4gi2BBX3wbCEJ4p4vpVWKpG6ja2aQP2ACBUv
+  HbSAUDjzpr44fWzf9Ynj3V1jq3wBsgg88N88P4vzeGPX
+
+tokens: |
+  7XtmNSHJDHTZdx2K1S8D529kHsBbt3Civxt6vUHrGxBR
+  65FKbLPtrssmc8aVn9DEBY8VTGB85vsgadrmaW9H4nEB
+
+nodes: |
+  https://api.mainnet-beta.solana.com
+#  https://rpc.ankr.com/solana

mm_sol/cli/examples/transfer-sol.yml

@@ -0,0 +1,8 @@
+from_address: ERB7SPx1XxH35pLu4Lkg9ChPQgsnwJGLZG8RsEE87XNw
+private_key: 3h92ZLyibvqQ9f923s66eN7V1iyG5WRRo3y9nciH4swUiLrkrYRdRM8q3DrtJ9JjTjiU9BT2r2qNzuiCmcZPVvqV
+amount: 1.2 # in SOL
+recipients:
+  - Rjg3K9PPDm1B5bmUP7eXZNfmApgvDPF9SrTh12dLRH9
+
+nodes: |
+  https://api.mainnet-beta.solana.com