mm-sol 0.2.5__py3-none-any.whl

mm_sol/rpc.py

@@ -0,0 +1,232 @@
+from typing import Any
+
+from mm_std import Err, Ok, Result, hr
+from pydantic import BaseModel, ConfigDict, Field
+
+DEFAULT_MAINNET_RPC = "https://api.mainnet-beta.solana.com"
+DEFAULT_TESTNET_RPC = "https://api.testnet.solana.com"
+
+
+class EpochInfo(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    epoch: int
+    absolute_slot: int = Field(..., alias="absoluteSlot")
+    block_height: int = Field(..., alias="blockHeight")
+    slot_index: int = Field(..., alias="slotIndex")
+    slots_in_epoch: int = Field(..., alias="slotsInEpoch")
+    transaction_count: int = Field(..., alias="transactionCount")
+
+    @property
+    def progress(self) -> float:
+        return round(self.slot_index / self.slots_in_epoch * 100, 2)
+
+
+class ClusterNode(BaseModel):
+    pubkey: str
+    version: str | None
+    gossip: str | None
+    rpc: str | None
+
+
+class VoteAccount(BaseModel):
+    class EpochCredits(BaseModel):
+        epoch: int
+        credits: int
+        previous_credits: int
+
+    validator: str
+    vote: str
+    commission: int
+    stake: int
+    credits: list[EpochCredits]
+    epoch_vote_account: bool
+    root_slot: int
+    last_vote: int
+    delinquent: bool
+
+
+class BlockProduction(BaseModel):
+    class Leader(BaseModel):
+        address: str
+        produced: int
+        skipped: int
+
+    slot: int
+    first_slot: int
+    last_slot: int
+    leaders: list[Leader]
+
+    @property
+    def total_produced(self) -> int:
+        return sum(leader.produced for leader in self.leaders)
+
+    @property
+    def total_skipped(self) -> int:
+        return sum(leader.skipped for leader in self.leaders)
+
+
+class StakeActivation(BaseModel):
+    state: str
+    active: int
+    inactive: int
+
+
+def rpc_call(
+    *,
+    node: str,
+    method: str,
+    params: list[Any],
+    id_: int = 1,
+    timeout: int = 10,
+    proxy: str | None = None,
+) -> Result[Any]:
+    data = {"jsonrpc": "2.0", "method": method, "params": params, "id": id_}
+    if node.startswith("http"):
+        return _http_call(node, data, timeout, proxy)
+    raise NotImplementedError("ws is not implemented")
+
+
+def _http_call(node: str, data: dict[str, object], timeout: int, proxy: str | None) -> Result[Any]:
+    res = hr(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}")
+
+
+def get_balance(node: str, address: str, timeout: int = 10, proxy: str | None = None) -> Result[int]:
+    """Returns balance in lamports"""
+    return rpc_call(node=node, method="getBalance", params=[address], timeout=timeout, proxy=proxy).and_then(lambda r: r["value"])
+
+
+def get_block_height(node: str, timeout: int = 10, proxy: str | None = None) -> Result[int]:
+    """Returns balance in lamports"""
+    return rpc_call(node=node, method="getBlockHeight", params=[], timeout=timeout, proxy=proxy)
+
+
+def get_slot(node: str, timeout: int = 10, proxy: str | None = None) -> Result[int]:
+    return rpc_call(node=node, method="getSlot", params=[], timeout=timeout, proxy=proxy)
+
+
+def get_epoch_info(node: str, epoch: int | None = None, timeout: int = 10, proxy: str | None = None) -> Result[EpochInfo]:
+    params = [epoch] if epoch else []
+    return rpc_call(node=node, method="getEpochInfo", params=params, timeout=timeout, proxy=proxy).and_then(
+        lambda r: EpochInfo(**r),
+    )
+
+
+def get_health(node: str, timeout: int = 10, proxy: str | None = None) -> Result[bool]:
+    return rpc_call(node=node, method="getHealth", params=[], timeout=timeout, proxy=proxy).and_then(lambda r: r == "ok")
+
+
+def get_cluster_nodes(node: str, timeout: int = 30, proxy: str | None = None) -> Result[list[ClusterNode]]:
+    return rpc_call(node=node, method="getClusterNodes", timeout=timeout, proxy=proxy, params=[]).and_then(
+        lambda r: [ClusterNode(**n) for n in r],
+    )
+
+
+def get_vote_accounts(node: str, timeout: int = 30, proxy: str | None = None) -> Result[list[VoteAccount]]:
+    res = rpc_call(node=node, method="getVoteAccounts", timeout=timeout, proxy=proxy, params=[])
+    if res.is_err():
+        return res
+    try:
+        data = res.unwrap()
+        result: list[VoteAccount] = []
+        for a in data["current"]:
+            result.append(  # noqa: PERF401
+                VoteAccount(
+                    validator=a["nodePubkey"],
+                    vote=a["votePubkey"],
+                    commission=a["commission"],
+                    stake=a["activatedStake"],
+                    credits=[
+                        VoteAccount.EpochCredits(epoch=c[0], credits=c[1], previous_credits=c[2]) for c in a["epochCredits"]
+                    ],
+                    delinquent=False,
+                    epoch_vote_account=a["epochVoteAccount"],
+                    root_slot=a["rootSlot"],
+                    last_vote=a["lastVote"],
+                ),
+            )
+        for a in data["delinquent"]:
+            result.append(  # noqa: PERF401
+                VoteAccount(
+                    validator=a["nodePubkey"],
+                    vote=a["votePubkey"],
+                    commission=a["commission"],
+                    stake=a["activatedStake"],
+                    credits=[
+                        VoteAccount.EpochCredits(epoch=c[0], credits=c[1], previous_credits=c[2]) for c in a["epochCredits"]
+                    ],
+                    delinquent=True,
+                    epoch_vote_account=a["epochVoteAccount"],
+                    root_slot=a["rootSlot"],
+                    last_vote=a["lastVote"],
+                ),
+            )
+        return Ok(result, res.data)
+    except Exception as e:
+        return Err(e, res.data)
+
+
+def get_leader_scheduler(
+    node: str,
+    slot: int | None = None,
+    timeout: int = 10,
+    proxy: str | None = None,
+) -> Result[dict[str, list[int]]]:
+    return rpc_call(
+        node=node,
+        method="getLeaderSchedule",
+        timeout=timeout,
+        proxy=proxy,
+        params=[slot],
+    )
+
+
+def get_block_production(node: str, timeout: int = 60, proxy: str | None = None) -> Result[BlockProduction]:
+    res = rpc_call(node=node, method="getBlockProduction", timeout=timeout, proxy=proxy, params=[])
+    if res.is_err():
+        return res
+    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 Ok(BlockProduction(slot=slot, first_slot=first_slot, last_slot=last_slot, leaders=leaders), res.data)
+    except Exception as e:
+        return Err(e, data=res.data)
+
+
+def get_stake_activation(node: str, address: str, timeout: int = 60, proxy: str | None = None) -> Result[StakeActivation]:
+    return rpc_call(node=node, method="getStakeActivation", timeout=timeout, proxy=proxy, params=[address]).and_then(
+        lambda ok: StakeActivation(**ok),
+    )
+
+
+def get_transaction(
+    node: str,
+    signature: str,
+    max_supported_transaction_version: int | None = None,
+    encoding: str = "json",
+    timeout: int = 60,
+    proxy: str | None = None,
+) -> Result[dict[str, object] | None]:
+    if max_supported_transaction_version is not None:
+        params = [signature, {"maxSupportedTransactionVersion": max_supported_transaction_version, "encoding": encoding}]
+    else:
+        params = [signature, encoding]
+    return rpc_call(node=node, method="getTransaction", timeout=timeout, proxy=proxy, params=params)

mm_sol/solana_cli.py

@@ -0,0 +1,254 @@
+import json
+import random
+from decimal import Decimal
+from pathlib import Path
+from typing import Literal
+
+import pydash
+from mm_std import CommandResult, Err, Ok, Result, run_command, run_ssh_command
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+class ValidatorInfo(BaseModel):
+    identity_address: str
+    info_address: str
+    name: str | None
+    keybase: str | None
+    website: str | None
+    details: str | None
+
+
+class StakeAccount(BaseModel):
+    type: str = Field(..., alias="stakeType")
+    balance: float | None = Field(..., alias="accountBalance")
+    withdrawer: str
+    staker: str
+    vote: str | None = Field(None, alias="delegatedVoteAccountAddress")
+
+    @field_validator("balance")
+    @classmethod
+    def from_lamports_to_sol(cls, v: int | None) -> float | None:
+        if v:
+            return v / 1_000_000_000
+
+
+class Stake(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    stake_address: str = Field(..., alias="stakePubkey")
+    withdrawer_address: str = Field(..., alias="withdrawer")
+    vote_address: str | None = Field(None, alias="delegatedVoteAccountAddress")
+    balance: float | None = Field(..., alias="accountBalance")
+    delegated: float | None = Field(None, alias="delegatedStake")
+    active: float | None = Field(None, alias="activeStake")
+    lock_time: int | None = Field(None, alias="unixTimestamp")
+
+    @field_validator("balance", "delegated", "active")
+    @classmethod
+    def from_lamports_to_sol(cls, v: int | None) -> float | None:
+        if v:
+            return v / 1_000_000_000
+
+
+def get_balance(
+    *,
+    address: str,
+    solana_dir: str = "",
+    url: str = "localhost",
+    ssh_host: str | None = None,
+    ssh_key_path: str | None = None,
+    timeout: int = 60,
+) -> Result[Decimal]:
+    solana_dir = _solana_dir(solana_dir)
+    cmd = f"{solana_dir}solana balance {address} -u {url}"
+    res = _exec_cmd(cmd, ssh_host, ssh_key_path, timeout)
+    data = {"cmd": cmd, "stdout": res.stdout, "stderr": res.stderr}
+    try:
+        return Ok(Decimal(res.stdout.replace("SOL", "").strip()), data=data)
+    except Exception as e:
+        return Err(e, data=data)
+
+
+def get_stake_account(
+    *,
+    address: str,
+    solana_dir: str = "",
+    url: str = "localhost",
+    ssh_host: str | None = None,
+    ssh_key_path: str | None = None,
+    timeout: int = 60,
+) -> Result[StakeAccount]:
+    solana_dir = _solana_dir(solana_dir)
+    cmd = f"{solana_dir}solana stake-account --output json -u {url} {address}"
+    res = _exec_cmd(cmd, ssh_host, ssh_key_path, timeout)
+    data = {"cmd": cmd, "stdout": res.stdout, "stderr": res.stderr}
+    try:
+        json_res = json.loads(res.stdout)
+        return Ok(StakeAccount(**json_res), data=data)
+    except Exception as e:
+        return Err(e, data=data)
+
+
+def transfer_with_private_key_file(
+    *,
+    recipient: str,
+    amount: Decimal,
+    private_key_path: str,
+    solana_dir: str = "",
+    url: str = "localhost",
+    ssh_host: str | None = None,
+    ssh_key_path: str | None = None,
+    allow_unfunded_recipient: bool = True,
+    timeout: int = 60,
+) -> Result[str]:
+    solana_dir = _solana_dir(solana_dir)
+    cmd = f"{solana_dir}solana transfer {recipient} {amount} --from {private_key_path} --fee-payer {private_key_path}"
+    if allow_unfunded_recipient:
+        cmd += " --allow-unfunded-recipient"
+    cmd += f" -u {url} --output json"
+    res = _exec_cmd(cmd, ssh_host, ssh_key_path, timeout)
+    data = {"cmd": cmd, "stdout": res.stdout, "stderr": res.stderr}
+    try:
+        json_res = json.loads(res.stdout)
+        return Ok(json_res["signature"], data=data)
+    except Exception as e:
+        return Err(e, data=data)
+
+
+def transfer_with_private_key_str(
+    *,
+    recipient: str,
+    amount: Decimal,
+    private_key: str,
+    tmp_dir_path: str,
+    solana_dir: str = "",
+    url: str = "localhost",
+    ssh_host: str | None = None,
+    ssh_key_path: str | None = None,
+    timeout: int = 60,
+) -> Result[str]:
+    # make private_key file
+    private_key_path = Path(f"{tmp_dir_path}/solana__{random.randint(1, 10_000_000_000)}.json")
+    private_key_path.write_text(private_key)
+
+    try:
+        return transfer_with_private_key_file(
+            recipient=recipient,
+            amount=amount,
+            private_key_path=private_key_path.as_posix(),
+            solana_dir=solana_dir,
+            url=url,
+            ssh_host=ssh_host,
+            ssh_key_path=ssh_key_path,
+            timeout=timeout,
+        )
+    finally:
+        private_key_path.unlink()
+
+
+def withdraw_from_vote_account(
+    *,
+    recipient: str,
+    amount: Decimal | Literal["ALL"],
+    vote_key_path: str,
+    fee_payer_key_path: str,
+    solana_dir: str = "",
+    url: str = "localhost",
+    ssh_host: str | None = None,
+    ssh_key_path: str | None = None,
+    timeout: int = 60,
+) -> Result[str]:
+    solana_dir = _solana_dir(solana_dir)
+    cmd = f"{solana_dir}solana withdraw-from-vote-account --keypair {fee_payer_key_path} -u {url} --output json {vote_key_path} {recipient} {amount}"  # noqa: E501
+    res = _exec_cmd(cmd, ssh_host, ssh_key_path, timeout)
+    data = {"cmd": cmd, "stdout": res.stdout, "stderr": res.stderr}
+    try:
+        json_res = json.loads(res.stdout)
+        return Ok(json_res["signature"], data=data)
+    except Exception as e:
+        return Err(e, data=data)
+
+
+def get_validators_info(
+    *,
+    solana_dir: str = "",
+    url: str = "localhost",
+    ssh_host: str | None = None,
+    ssh_key_path: str | None = None,
+    timeout: int = 60,
+) -> Result[list[ValidatorInfo]]:
+    solana_dir = _solana_dir(solana_dir)
+    cmd = f"{solana_dir}solana validator-info get --output json -u {url}"
+    res = _exec_cmd(cmd, ssh_host, ssh_key_path, timeout)
+    data = {"cmd": cmd, "stdout": res.stdout, "stderr": res.stderr}
+    try:
+        validators = []
+        for v in json.loads(res.stdout):
+            validators.append(  # noqa: PERF401
+                ValidatorInfo(
+                    info_address=v["infoPubkey"],
+                    identity_address=v["identityPubkey"],
+                    name=pydash.get(v, "info.name"),
+                    keybase=pydash.get(v, "info.keybaseUsername"),
+                    details=pydash.get(v, "info.details"),
+                    website=pydash.get(v, "info.website"),
+                ),
+            )
+        return Ok(validators, data=data)
+    except Exception as e:
+        return Err(e, data=data)
+
+
+def get_vote_account_rewards(
+    *,
+    address: str,
+    solana_dir: str = "",
+    url: str = "localhost",
+    ssh_host: str | None = None,
+    ssh_key_path: str | None = None,
+    num_rewards_epochs: int = 10,
+    timeout: int = 60,
+) -> Result[dict[int, float]]:
+    solana_dir = _solana_dir(solana_dir)
+    cmd = f"{solana_dir}solana vote-account {address} --with-rewards --num-rewards-epochs={num_rewards_epochs} -u {url}"
+    cmd += " --output json 2>/dev/null"
+    res = _exec_cmd(cmd, ssh_host, ssh_key_path, timeout)
+    data = {"cmd": cmd, "stdout": res.stdout, "stderr": res.stderr}
+    try:
+        rewards: dict[int, float] = {}
+        for r in reversed(json.loads(res.stdout)["epochRewards"]):
+            rewards[r["epoch"]] = r["amount"] / 10**9
+        return Ok(rewards, data=data)
+    except Exception as e:
+        return Err(e, data=data)
+
+
+def get_stakes(
+    *,
+    vote_address: str = "",
+    solana_dir: str = "",
+    url: str = "localhost",
+    ssh_host: str | None = None,
+    ssh_key_path: str | None = None,
+    timeout: int = 60,
+) -> Result[list[Stake]]:
+    solana_dir = _solana_dir(solana_dir)
+    cmd = f"{solana_dir}solana stakes --output json -u {url} {vote_address}"
+    res = _exec_cmd(cmd, ssh_host, ssh_key_path, timeout)
+    data = {"stdout": res.stdout, "stderr": res.stderr}
+    try:
+        return Ok([Stake(**x) for x in json.loads(res.stdout)], data=data)
+    except Exception as e:
+        return Err(e, data=data)
+
+
+def _exec_cmd(cmd: str, ssh_host: str | None, ssh_key_path: str | None, timeout: int) -> CommandResult:
+    if ssh_host:
+        return run_ssh_command(ssh_host, cmd, ssh_key_path, timeout=timeout)
+    return run_command(cmd, timeout=timeout)
+
+
+def _solana_dir(solana_dir: str) -> str:
+    if solana_dir and not solana_dir.endswith("/"):
+        solana_dir += "/"
+    return solana_dir

mm_sol/token.py

@@ -0,0 +1,133 @@
+from mm_std import Err, Ok, Result
+from solana.exceptions import SolanaRpcException
+from solana.rpc.types import TokenAccountOpts
+from solders.pubkey import Pubkey
+
+from mm_sol.types import Nodes, Proxies
+from mm_sol.utils import get_client, get_node, get_proxy
+
+
+def get_balance(
+    node: str,
+    owner_address: str,
+    token_mint_address: str,
+    token_account: str | None = None,
+    timeout: float = 10,
+    proxy: str | None = None,
+    no_token_accounts_return_zero: bool = True,
+) -> Result[int]:
+    try:
+        client = get_client(node, proxy=proxy, timeout=timeout)
+        if token_account:
+            res_balance = client.get_token_account_balance(Pubkey.from_string(token_account))
+            return Ok(int(res_balance.value.amount))
+
+        res_accounts = client.get_token_accounts_by_owner(
+            Pubkey.from_string(owner_address),
+            TokenAccountOpts(mint=Pubkey.from_string(token_mint_address)),
+        )
+
+        if no_token_accounts_return_zero and not res_accounts.value:
+            return Ok(0)
+        if not res_accounts.value:
+            return Err("no_token_accounts")
+
+        token_accounts = [a.pubkey for a in res_accounts.value]
+        balances = []
+        for token_account_ in token_accounts:
+            res = client.get_token_account_balance(token_account_)
+            if res.value:  # type:ignore[truthy-bool]
+                balances.append(int(res.value.amount))
+
+        if len(balances) > 1:
+            return Err("there are many non empty token accounts, set token_account explicitly")
+        return Ok(balances[0])
+    except SolanaRpcException as e:
+        return Err(e.error_msg)
+    except Exception as e:
+        return Err(e)
+
+
+def get_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,
+    no_token_accounts_return_zero: bool = True,
+) -> Result[int]:
+    res: Result[int] = Err("not started yet")
+    for _ in range(retries):
+        res = get_balance(
+            get_node(nodes),
+            owner_address,
+            token_mint_address,
+            token_account,
+            timeout=timeout,
+            proxy=get_proxy(proxies),
+            no_token_accounts_return_zero=no_token_accounts_return_zero,
+        )
+        if res.is_ok():
+            return res
+    return res
+
+
+def get_decimals(node: str, token_mint_address: str, timeout: float = 10, proxy: str | None = None) -> Result[int]:
+    try:
+        client = get_client(node, proxy=proxy, timeout=timeout)
+        res = client.get_token_supply(Pubkey.from_string(token_mint_address))
+        return Ok(res.value.decimals)
+    except Exception as e:
+        return Err(e)
+
+
+def get_decimals_with_retries(
+    nodes: Nodes, token_mint_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_decimals(get_node(nodes), token_mint_address, timeout=timeout, proxy=get_proxy(proxies))
+        if res.is_ok():
+            return res
+    return res
+
+
+# def transfer_to_wallet_address(
+#     *,
+#     node: str,
+#     private_key: str,
+#     recipient_wallet_address: str,
+#     token_mint_address: str,
+#     amount: int,
+# ) -> Result[str]:
+#     try:
+#         keypair = account.get_keypair(private_key)
+#         token_client = Token(Client(node), Pubkey.from_string(token_mint_address), program_id=TOKEN_PROGRAM_ID, payer=keypair)
+#
+#         # get from_token_account
+#         res = token_client.get_accounts(keypair.public_key)
+#         token_accounts = res["result"]["value"]
+#         if len(token_accounts) > 1:
+#             return Result(error="many_from_token_accounts", data=res)
+#         from_token_account = Pubkey.from_string(token_accounts[0]["pubkey"])
+#
+#         # get to_token_account
+#         res = token_client.get_accounts(Pubkey.from_string(recipient_wallet_address))
+#         token_accounts = res["result"]["value"]
+#         if len(token_accounts) > 1:
+#             return Result(error="many_to_token_accounts", data=res)
+#         elif len(token_accounts) == 1:
+#             to_token_account = Pubkey.from_string(token_accounts[0]["pubkey"])
+#         else:  # create a new to_token_account
+#             to_token_account = token_client.create_account(owner=Pubkey.from_string(recipient_wallet_address))
+#
+#         res = token_client.transfer(source=from_token_account, dest=to_token_account, owner=keypair, amount=amount)
+#         if res.get("result"):
+#             return Result(ok=res.get("result"), data=res)
+#         return Result(error="unknown_response", data=res)
+#     except RPCException as e:
+#         return Result(error="rcp_exception", data=str(e))
+#     except Exception as e:
+#         return Result(error="exception", data=str(e))

mm_sol/transfer.py

@@ -0,0 +1,80 @@
+from decimal import Decimal
+
+import pydash
+from mm_std import Err, Ok, Result
+from pydantic import BaseModel
+from solana.rpc.api import Client
+from solders.message import Message
+from solders.pubkey import Pubkey
+from solders.system_program import TransferParams, transfer
+from solders.transaction import Transaction
+
+from mm_sol import rpc, utils
+from mm_sol.account import check_private_key, get_keypair
+
+
+def transfer_sol(
+    *,
+    from_address: str,
+    private_key_base58: str,
+    recipient_address: str,
+    amount_sol: Decimal,
+    nodes: str | list[str] | None = None,
+    attempts: int = 3,
+) -> Result[str]:
+    acc = get_keypair(private_key_base58)
+    if not check_private_key(from_address, private_key_base58):
+        raise ValueError("from_address or private_key_base58 is invalid")
+
+    lamports = int(amount_sol * 10**9)
+    error = None
+    data = None
+    for _ in range(attempts):
+        try:
+            client = Client(utils.get_node(nodes))
+            # tx = Transaction(from_keypairs=[acc])
+            # ti = transfer(
+            #     TransferParams(from_pubkey=acc.pubkey(), to_pubkey=Pubkey.from_string(recipient_address), lamports=lamports),
+            # )
+            # tx.add(ti)
+            # res = client.send_legacy_transaction(tx, acc)
+            ixns = [
+                transfer(
+                    TransferParams(from_pubkey=acc.pubkey(), to_pubkey=Pubkey.from_string(recipient_address), lamports=lamports)
+                )
+            ]
+            msg = Message(ixns, acc.pubkey())
+            tx = Transaction([acc], msg, client.get_latest_blockhash().value.blockhash)
+            res = client.send_transaction(tx)
+            data = res.to_json()
+            return Ok(str(res.value), data=data)
+        except Exception as e:
+            error = e
+
+    return Err(error or "unknown", data=data)
+
+
+class TransferInfo(BaseModel):
+    source: str
+    destination: str
+    lamports: int
+
+
+def find_transfers(node: str, tx_signature: str) -> Result[list[TransferInfo]]:
+    res = rpc.get_transaction(node, tx_signature, encoding="jsonParsed")
+    if res.is_err():
+        return res  # type: ignore[return-value]
+    result = []
+    try:
+        for ix in pydash.get(res.ok, "transaction.message.instructions"):
+            program_id = ix.get("programId")
+            ix_type = pydash.get(ix, "parsed.type")
+            if program_id == "11111111111111111111111111111111" and ix_type == "transfer":
+                source = pydash.get(ix, "parsed.info.source")
+                destination = pydash.get(ix, "parsed.info.destination")
+                lamports = pydash.get(ix, "parsed.info.lamports")
+                if source and destination and lamports:
+                    result.append(TransferInfo(source=source, destination=destination, lamports=lamports))
+        return Ok(result, data=res.data)
+    except Exception as e:
+        return Err(e, res.data)

mm_sol/types.py

@@ -0,0 +1,4 @@
+from collections.abc import Sequence
+
+type Proxies = str | Sequence[str] | None
+type Nodes = str | Sequence[str]